@paraswap/dex-lib 2.19.1 → 2.20.0

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

@@ -905,39 +905,38 @@ describe('Solidly E2E', () => {
         ],
       ]);
 
-      const pairs: { name: string; sellAmount: string; }[][] =
+      const pairs: { name: string; sellAmount: string }[][] = [
         [
-          [
-            {
-              name: 'BNB',
-              sellAmount: '1000000000000000000',
-            },
-            {
-              name: 'USDT',
-              sellAmount: '10000000000000000000',
-            },
-          ],
-          [
-            {
-              name: 'USDT',
-              sellAmount: '10000000000000000000',
-            },
-            {
-              name: 'USDC',
-              sellAmount: '10000000000000000000',
-            },
-          ],
-          [
-            {
-              name: 'ETH',
-              sellAmount: '5000000000000000000',
-            },
-            {
-              name: 'BNB',
-              sellAmount: '1000000000000000000',
-            },
-          ]
-        ];
+          {
+            name: 'BNB',
+            sellAmount: '1000000000000000000',
+          },
+          {
+            name: 'USDT',
+            sellAmount: '10000000000000000000',
+          },
+        ],
+        [
+          {
+            name: 'USDT',
+            sellAmount: '10000000000000000000',
+          },
+          {
+            name: 'USDC',
+            sellAmount: '10000000000000000000',
+          },
+        ],
+        [
+          {
+            name: 'ETH',
+            sellAmount: '5000000000000000000',
+          },
+          {
+            name: 'BNB',
+            sellAmount: '1000000000000000000',
+          },
+        ],
+      ];
 
       sideToContractMethods.forEach((contractMethods, side) =>
         describe(`${side}`, () => {

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

@@ -116,10 +116,13 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
       getTokensResponseValidator,
     );
 
-    this.tokensMap = Object.keys(tokensResp.tokens).reduce((acc, key: string) => {
-      acc[key.toLowerCase()] = tokensResp.tokens[key];
-      return acc;
-    }, {} as TokensMap);
+    this.tokensMap = Object.keys(tokensResp.tokens).reduce(
+      (acc, key: string) => {
+        acc[key.toLowerCase()] = tokensResp.tokens[key];
+        return acc;
+      },
+      {} as TokensMap,
+    );
 
     if (!this.dexHelper.config.isSlave) {
       await this.rateFetcher.start();
@@ -281,7 +284,7 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     limitPools?: string[],
   ): Promise<null | ExchangePrices<SwaapV2Data>> {
     try {
-      if(await this.isRestricted()) {
+      if (await this.isRestricted()) {
         return null;
       }
 
@@ -332,7 +335,6 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
       );
 
       const prices = levelEntries.map((askAndBids: SwaapV2PriceLevels) => {
-
         const unitPrice = this.computePricesFromLevelsBids(
           [unitVolume],
           askAndBids,
@@ -361,7 +363,8 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
       return prices;
     } catch (e) {
       this.logger.error(
-        `Error_getPrices ${srcToken}, ${destToken}, ${side}:`, e,
+        `Error_getPrices ${srcToken}, ${destToken}, ${side}:`,
+        e,
       );
       return null;
     }
@@ -459,7 +462,7 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
       const quoteTokenAmount = BigInt(quote.amount);
       const slippageFactor = options.slippageFactor;
 
-      if(side === SwapSide.SELL) {
+      if (side === SwapSide.SELL) {
         if (
           quoteTokenAmount <
           BigInt(
@@ -798,8 +801,7 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
     tokenAddress: Address,
     limit: number,
   ): Promise<PoolLiquidity[]> {
-
-    if(await this.isRestricted()) {
+    if (await this.isRestricted()) {
       return [];
     }
 
@@ -821,7 +823,13 @@ export class SwaapV2 extends SimpleExchange implements IDex<SwaapV2Data> {
       .map((pair: string) => {
         return {
           exchange: this.dexKey,
-          connectorTokens: [this.getTokenFromAddress(normalizedTokenAddress === pLevels[pair].base ? pLevels[pair].quote : pLevels[pair].base)],
+          connectorTokens: [
+            this.getTokenFromAddress(
+              normalizedTokenAddress === pLevels[pair].base
+                ? pLevels[pair].quote
+                : pLevels[pair].base,
+            ),
+          ],
           liquidityUSD: this.computeMaxLiquidity(pLevels[pair], tokenAddress),
         } as PoolLiquidity;
       })

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

@@ -42,10 +42,10 @@ export type SwaapV2TokensResponse = {
       symbol: string;
       address: string;
       decimals: number;
-    },
-  },
+    };
+  };
   success: boolean;
-}
+};
 
 export type SwaapV2QuoteResponse = {
   id: string;
@@ -84,5 +84,5 @@ export type SwaapV2APIParameters = {
 };
 
 export type TokensMap = {
-  [address: string]: Token,
+  [address: string]: Token;
 };

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

@@ -11,11 +11,11 @@ export const getIdentifierPrefix = (
 
 export const getPairName = (srcAddress: Address, destAddress: Address) => {
   const sortedAddresses =
-  srcAddress < destAddress
-    ? [srcAddress, destAddress]
-    : [destAddress, srcAddress];
+    srcAddress < destAddress
+      ? [srcAddress, destAddress]
+      : [destAddress, srcAddress];
   return `${sortedAddresses[0]}_${sortedAddresses[1]}`.toLowerCase();
-}
+};
 
 export const getCacheKey = (dexKey: string, cacheType: string) => {
   return `${CACHE_PREFIX}_${dexKey}_${cacheType}`.toLowerCase();

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

@@ -3,7 +3,6 @@ import joi, { CustomHelpers, ErrorReport } from 'joi';
 import * as ethers from 'ethers';
 import { SwaapV2PriceLevel } from './types';
 
-
 const priceLevelsValidator = joi.array().items(
   joi.object({
     level: joi.number().required(),
@@ -107,12 +106,10 @@ const mustBeAugustusSwapper = (
       });
 };
 
-export const getTokensResponseValidator = joi
-  .object({
-    tokens: joi.object().required(),
-    success: joi.boolean().required(),
-  });
-
+export const getTokensResponseValidator = joi.object({
+  tokens: joi.object().required(),
+  success: joi.boolean().required(),
+});
 
 export const getQuoteResponseValidator = joi
   .object({

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

@@ -788,9 +788,15 @@ export class UniswapV2
     destToken: Address,
     srcAmount: NumberAsString,
     destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
     _data: UniswapData,
     side: SwapSide,
     permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
     contractMethod?: string,
   ): TxInfo<UniswapParam> {
     if (!contractMethod) throw new Error(`contractMethod need to be passed`);

package/src/dex/uniswap-v3/constants.ts

@@ -34,3 +34,8 @@ export const ZERO_ORACLE_OBSERVATION = {
 export const OUT_OF_RANGE_ERROR_POSTFIX = `INVALID_TICK_BIT_MAP_RANGES`;
 
 export const DEFAULT_POOL_INIT_CODE_HASH = `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`;
+
+export enum DirectMethods {
+  directSell = 'directUniV3Swap',
+  directBuy = 'directUniV3Buy',
+}

package/src/dex/uniswap-v3/types.ts

@@ -57,6 +57,7 @@ export type UniswapV3Data = {
     tokenOut: Address;
     fee: NumberAsString;
   }[];
+  isApproved?: boolean;
 };
 
 export type DexParams = {
@@ -72,7 +73,7 @@ export type DexParams = {
   initHash: string;
 };
 
-export type UniswapV3SellParam = {
+export type UniswapV3SimpleSwapSellParam = {
   path: string;
   recipient: Address;
   deadline: string;
@@ -80,7 +81,7 @@ export type UniswapV3SellParam = {
   amountOutMinimum: NumberAsString;
 };
 
-export type UniswapV3BuyParam = {
+export type UniswapV3SimpleSwapBuyParam = {
   path: string;
   recipient: Address;
   deadline: string;
@@ -88,7 +89,26 @@ export type UniswapV3BuyParam = {
   amountInMaximum: NumberAsString;
 };
 
-export type UniswapV3Param = UniswapV3SellParam | UniswapV3BuyParam;
+export type UniswapV3SimpleSwapParams =
+  | UniswapV3SimpleSwapSellParam
+  | UniswapV3SimpleSwapBuyParam;
+
+export type UniswapV3Param = [
+  fromToken: Address,
+  toToken: Address,
+  exchange: Address,
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  expectedAmount: NumberAsString,
+  feePercent: NumberAsString,
+  deadline: NumberAsString,
+  partner: Address,
+  isApproved: boolean,
+  beneficiary: Address,
+  path: string,
+  permit: string,
+  uuid: string,
+];
 
 export enum UniswapV3Functions {
   exactInput = 'exactInput',

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

@@ -49,6 +49,20 @@ describe('UniswapV3 E2E', () => {
         provider,
       );
     });
+
+    it('directSwap SELL WETH -> USDC', async () => {
+      await testE2E(
+        tokens['WETH'],
+        tokens['USDC'],
+        holders['WETH'],
+        '1000000000000000000',
+        SwapSide.SELL,
+        dexKey,
+        ContractMethod.directUniV3Swap,
+        network,
+        provider,
+      );
+    });
   });
 
   describe('UniswapV3 POLYGON', () => {
@@ -64,7 +78,7 @@ describe('UniswapV3 E2E', () => {
     const tokenBSymbol: string = 'WETH';
     const nativeTokenSymbol = NativeTokenSymbols[network];
 
-    const tokenAAmount: string = '11111000000';
+    const tokenAAmount: string = '11000000';
     const tokenBAmount: string = '11000000000000000000';
     const nativeTokenAmount = '11000000000000000000';
 
@@ -75,9 +89,17 @@ describe('UniswapV3 E2E', () => {
           ContractMethod.simpleSwap,
           ContractMethod.multiSwap,
           ContractMethod.megaSwap,
+          ContractMethod.directUniV3Swap,
+        ],
+      ],
+      [
+        SwapSide.BUY,
+        [
+          ContractMethod.simpleBuy,
+          ContractMethod.buy,
+          ContractMethod.directUniV3Buy,
         ],
       ],
-      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
     ]);
 
     sideToContractMethods.forEach((contractMethods, side) =>
@@ -202,4 +224,80 @@ describe('UniswapV3 E2E', () => {
       }),
     );
   });
+
+  describe('UniswapV3 Optimism', () => {
+    const network = Network.OPTIMISM;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    const tokenASymbol: string = 'OP';
+    const tokenBSymbol: string = 'ETH';
+    const nativeTokenSymbol = NativeTokenSymbols[network];
+
+    const tokenAAmount: string = '1000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
+    const nativeTokenAmount = '1000000000000000000';
+
+    const sideToContractMethods = new Map([
+      [
+        SwapSide.SELL,
+        [
+          ContractMethod.simpleSwap,
+          ContractMethod.multiSwap,
+          ContractMethod.megaSwap,
+        ],
+      ],
+      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+    ]);
+
+    sideToContractMethods.forEach((contractMethods, side) =>
+      contractMethods.forEach((contractMethod: ContractMethod) => {
+        describe(`${contractMethod}`, () => {
+          it(`${network} ${side} ${contractMethod} ${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+            await testE2E(
+              tokens[nativeTokenSymbol],
+              tokens[tokenASymbol],
+              holders[nativeTokenSymbol],
+              side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+          it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+            await testE2E(
+              tokens[tokenASymbol],
+              tokens[nativeTokenSymbol],
+              holders[tokenASymbol],
+              side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+          it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+            await testE2E(
+              tokens[tokenASymbol],
+              tokens[tokenBSymbol],
+              holders[tokenASymbol],
+              side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+              side,
+              dexKey,
+              contractMethod,
+              network,
+              provider,
+            );
+          });
+        });
+      }),
+    );
+  });
 });

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

@@ -11,6 +11,9 @@ import {
   Logger,
   NumberAsString,
   PoolPrices,
+  TxInfo,
+  PreprocessTransactionOptions,
+  ExchangeTxInfo,
 } from '../../types';
 import { SwapSide, Network, CACHE_PREFIX } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -19,6 +22,7 @@ import {
   getDexKeysWithNetwork,
   interpolate,
   isTruthy,
+  uuidToBytes16,
 } from '../../utils';
 import { IDex } from '../../dex/idex';
 import { IDexHelper } from '../../dex-helper/idex-helper';
@@ -29,6 +33,7 @@ import {
   UniswapV3Data,
   UniswapV3Functions,
   UniswapV3Param,
+  UniswapV3SimpleSwapParams,
 } from './types';
 import {
   getLocalDeadlineAsFriendlyPlaceholder,
@@ -39,14 +44,16 @@ import { UniswapV3EventPool } from './uniswap-v3-pool';
 import UniswapV3RouterABI from '../../abi/uniswap-v3/UniswapV3Router.abi.json';
 import UniswapV3QuoterABI from '../../abi/uniswap-v3/UniswapV3Quoter.abi.json';
 import UniswapV3MultiABI from '../../abi/uniswap-v3/UniswapMulti.abi.json';
+import DirectSwapABI from '../../abi/DirectSwap.json';
 import UniswapV3StateMulticallABI from '../../abi/uniswap-v3/UniswapV3StateMulticall.abi.json';
 import {
+  DirectMethods,
   UNISWAPV3_EFFICIENCY_FACTOR,
   UNISWAPV3_POOL_SEARCH_OVERHEAD,
   UNISWAPV3_TICK_BASE_OVERHEAD,
   UNISWAPV3_TICK_GAS_COST,
 } from './constants';
-import { DeepReadonly } from 'ts-essentials';
+import { assert, DeepReadonly } from 'ts-essentials';
 import { uniswapV3Math } from './contract-math/uniswap-v3-math';
 import { Contract } from 'web3-eth-contract';
 import { AbiItem } from 'web3-utils';
@@ -56,6 +63,7 @@ import {
   DEFAULT_ID_ERC20,
   DEFAULT_ID_ERC20_AS_STRING,
 } from '../../lib/tokens/types';
+import { OptimalSwapExchange } from '@paraswap/core';
 
 type PoolPairsInfo = {
   token0: Address;
@@ -77,6 +85,8 @@ export class UniswapV3
   readonly hasConstantPriceLargeAmounts = false;
   readonly needWrapNative = true;
 
+  readonly directSwapIface = new Interface(DirectSwapABI);
+
   intervalTask?: NodeJS.Timeout;
 
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
@@ -113,7 +123,7 @@ export class UniswapV3
     // To receive revert reasons
     this.dexHelper.web3Provider.eth.handleRevert = false;
 
-    // Normalise once all config addresses and use across all scenarios
+    // Normalize once all config addresses and use across all scenarios
     this.config = this._toLowerForAllConfigAddresses();
 
     this.notExistingPoolSetKey =
@@ -449,6 +459,7 @@ export class UniswapV3
               fee: pool.feeCodeAsString,
             },
           ],
+          exchange: pool.poolAddress,
         },
         poolIdentifier: this.getPoolIdentifier(
           pool.token0,
@@ -731,6 +742,130 @@ export class UniswapV3
     return arr;
   }
 
+  getTokenFromAddress(address: Address): Token {
+    // In this Dex decimals are not used
+    return { address, decimals: 0 };
+  }
+
+  async preProcessTransaction(
+    optimalSwapExchange: OptimalSwapExchange<UniswapV3Data>,
+    srcToken: Token,
+    _0: Token,
+    _1: SwapSide,
+    options: PreprocessTransactionOptions,
+  ): Promise<[OptimalSwapExchange<UniswapV3Data>, 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, this.config.router)
+        .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()),
+      },
+    ];
+  }
+
+  getDirectParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
+    data: UniswapV3Data,
+    side: SwapSide,
+    permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
+    contractMethod?: string,
+  ): TxInfo<UniswapV3Param> {
+    if (
+      contractMethod !== DirectMethods.directSell &&
+      contractMethod !== DirectMethods.directBuy
+    ) {
+      throw new Error(`Invalid contract method ${contractMethod}`);
+    }
+
+    let isApproved: boolean = !!data.isApproved;
+    if (data.isApproved === undefined) {
+      this.logger.warn(`isApproved is undefined, defaulting to false`);
+    }
+
+    const path = this._encodePath(data.path, side);
+
+    const swapParams: UniswapV3Param = [
+      srcToken,
+      destToken,
+      this.config.router,
+      srcAmount,
+      destAmount,
+      expectedAmount,
+      feePercent,
+      deadline,
+      partner,
+      isApproved,
+      beneficiary,
+      path,
+      permit,
+      uuidToBytes16(uuid),
+    ];
+
+    const encoder = (...params: UniswapV3Param) => {
+      return this.directSwapIface.encodeFunctionData(
+        side === SwapSide.SELL
+          ? DirectMethods.directSell
+          : DirectMethods.directBuy,
+        [params],
+      );
+    };
+
+    return {
+      params: swapParams,
+      encoder,
+      networkFee: '0',
+    };
+  }
+
+  static getDirectFunctionName(): string[] {
+    return [DirectMethods.directSell, DirectMethods.directBuy];
+  }
+
   async getSimpleParam(
     srcToken: string,
     destToken: string,
@@ -745,7 +880,7 @@ export class UniswapV3
         : UniswapV3Functions.exactOutput;
 
     const path = this._encodePath(data.path, side);
-    const swapFunctionParams: UniswapV3Param =
+    const swapFunctionParams: UniswapV3SimpleSwapParams =
       side === SwapSide.SELL
         ? {
             recipient: this.augustusAddress,

package/src/dex/zerox/index.ts

@@ -269,9 +269,16 @@ export class ZeroX
     destToken: Address,
     srcAmount: NumberAsString,
     destAmount: NumberAsString,
+    expectedAmount: NumberAsString,
     data: ZeroXData,
     side: SwapSide,
     permit: string,
+    uuid: string,
+    feePercent: NumberAsString,
+    deadline: NumberAsString,
+    partner: string,
+    beneficiary: string,
+    contractMethod?: string,
   ): TxInfo<ZeroXParam> {
     const usePermit = permit !== '0x';
     const encoder = (...params: ZeroXParam) => {

package/src/implementations/local-paraswap-sdk.ts

@@ -17,6 +17,8 @@ import {
 } from '../types';
 import { SwapSide, NULL_ADDRESS, ContractMethod } from '../constants';
 import { LimitOrderExchange } from '../dex/limit-order-exchange';
+import { v4 as uuid } from 'uuid';
+import { DirectContractMethods } from '@paraswap/core/build/constants';
 
 export interface IParaSwapSDK {
   getPrices(
@@ -205,6 +207,8 @@ export class LocalParaswapSDK implements IParaSwapSDK {
         : priceRoute.srcAmount,
     );
 
+    const contractMethod = priceRoute.contractMethod;
+
     // Call preprocessTransaction for each exchange before we build transaction
     try {
       priceRoute.bestRoute = await Promise.all(
@@ -234,6 +238,9 @@ export class LocalParaswapSDK implements IParaSwapSDK {
                         {
                           slippageFactor,
                           txOrigin: userAddress,
+                          isDirectMethod: DirectContractMethods.includes(
+                            contractMethod as ContractMethod,
+                          ),
                         },
                       );
 
@@ -264,7 +271,7 @@ export class LocalParaswapSDK implements IParaSwapSDK {
       partnerAddress: NULL_ADDRESS,
       partnerFeePercent: '0',
       deadline: deadline.toString(),
-      uuid: '00000000-0000-0000-0000-000000000000',
+      uuid: uuid(),
     });
   }
 }