@paraswap/dex-lib 2.21.0 → 2.21.1-chronos

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

@@ -11,6 +11,7 @@ import { Interface, Result } from '@ethersproject/abi';
 import solidlyPairABI from '../../abi/solidly/SolidlyPair.json';
 import { SpiritSwapV2 } from './forks-override/spiritSwapV2';
 import { Cone } from './forks-override/cone';
+import { Chronos } from './forks-override/chronos';
 
 const amounts18 = [0n, BI_POWS[18], 2000000000000000000n];
 const amounts6 = [0n, BI_POWS[6], 2000000n];
@@ -628,4 +629,144 @@ describe('Solidly integration tests', () => {
       });
     });
   });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+    const dexHelper = new DummyDexHelper(network);
+    const checkOnChainPricing = constructCheckOnChainPricing(dexHelper);
+
+    describe('Chronos', function () {
+      const dexKey = 'Chronos';
+      const chronos = new Chronos(network, dexKey, dexHelper);
+
+      describe('UniswapV2 like pool', function () {
+        const TokenASymbol = 'USDC';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'WETH';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts18;
+
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await chronos.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await chronos.getPricesVolume(
+            tokenA,
+            tokenB,
+            amounts,
+            SwapSide.SELL,
+            blocknumber,
+            pools,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+            poolPrices,
+          );
+
+          expect(poolPrices).not.toBeNull();
+          checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+          // Check if onchain pricing equals to calculated ones
+
+          for (const i in poolPrices || []) {
+            await checkOnChainPricing(
+              chronos,
+              'getAmountOut',
+              blocknumber,
+              poolPrices![i].prices,
+              poolPrices![i].poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+
+        it('getTopPoolsForToken', async function () {
+          const poolLiquidity = await chronos.getTopPoolsForToken(
+            tokenA.address,
+            10,
+          );
+          console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+          checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+        });
+      });
+
+      describe('Curve like stable pool', function () {
+        const TokenASymbol = 'USDT';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'USDC';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts6;
+
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await chronos.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await chronos.getPricesVolume(
+            tokenA,
+            tokenB,
+            amounts,
+            SwapSide.SELL,
+            blocknumber,
+            pools,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+            poolPrices,
+          );
+
+          expect(poolPrices).not.toBeNull();
+          checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+          // Check if onchain pricing equals to calculated ones
+          for (const i in poolPrices || []) {
+            await checkOnChainPricing(
+              chronos,
+              'getAmountOut',
+              blocknumber,
+              poolPrices![i].prices,
+              poolPrices![i].poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+
+        it('getTopPoolsForToken', async function () {
+          const poolLiquidity = await chronos.getTopPoolsForToken(
+            tokenA.address,
+            10,
+          );
+          console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+          checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+        });
+      });
+    });
+  });
 });

package/src/dex/solidly/solidly.ts

@@ -71,6 +71,7 @@ export class Solidly extends UniswapV2 {
         'SolidlyV2',
         'Thena',
         'SoliSnek',
+        'Chronos',
       ]),
     );
 

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

@@ -788,15 +788,9 @@ 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,8 +34,3 @@ 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,7 +57,6 @@ export type UniswapV3Data = {
     tokenOut: Address;
     fee: NumberAsString;
   }[];
-  isApproved?: boolean;
 };
 
 export type DexParams = {
@@ -73,7 +72,7 @@ export type DexParams = {
   initHash: string;
 };
 
-export type UniswapV3SimpleSwapSellParam = {
+export type UniswapV3SellParam = {
   path: string;
   recipient: Address;
   deadline: string;
@@ -81,7 +80,7 @@ export type UniswapV3SimpleSwapSellParam = {
   amountOutMinimum: NumberAsString;
 };
 
-export type UniswapV3SimpleSwapBuyParam = {
+export type UniswapV3BuyParam = {
   path: string;
   recipient: Address;
   deadline: string;
@@ -89,26 +88,7 @@ export type UniswapV3SimpleSwapBuyParam = {
   amountInMaximum: NumberAsString;
 };
 
-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 type UniswapV3Param = UniswapV3SellParam | UniswapV3BuyParam;
 
 export enum UniswapV3Functions {
   exactInput = 'exactInput',

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

@@ -49,20 +49,6 @@ 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', () => {
@@ -78,7 +64,7 @@ describe('UniswapV3 E2E', () => {
     const tokenBSymbol: string = 'WETH';
     const nativeTokenSymbol = NativeTokenSymbols[network];
 
-    const tokenAAmount: string = '11000000';
+    const tokenAAmount: string = '11111000000';
     const tokenBAmount: string = '11000000000000000000';
     const nativeTokenAmount = '11000000000000000000';
 
@@ -89,17 +75,9 @@ 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) =>
@@ -224,80 +202,4 @@ 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,9 +11,6 @@ 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';
@@ -22,7 +19,6 @@ import {
   getDexKeysWithNetwork,
   interpolate,
   isTruthy,
-  uuidToBytes16,
 } from '../../utils';
 import { IDex } from '../../dex/idex';
 import { IDexHelper } from '../../dex-helper/idex-helper';
@@ -33,7 +29,6 @@ import {
   UniswapV3Data,
   UniswapV3Functions,
   UniswapV3Param,
-  UniswapV3SimpleSwapParams,
 } from './types';
 import {
   getLocalDeadlineAsFriendlyPlaceholder,
@@ -44,16 +39,14 @@ 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 { assert, DeepReadonly } from 'ts-essentials';
+import { DeepReadonly } from 'ts-essentials';
 import { uniswapV3Math } from './contract-math/uniswap-v3-math';
 import { Contract } from 'web3-eth-contract';
 import { AbiItem } from 'web3-utils';
@@ -63,7 +56,6 @@ import {
   DEFAULT_ID_ERC20,
   DEFAULT_ID_ERC20_AS_STRING,
 } from '../../lib/tokens/types';
-import { OptimalSwapExchange } from '@paraswap/core';
 
 type PoolPairsInfo = {
   token0: Address;
@@ -85,8 +77,6 @@ export class UniswapV3
   readonly hasConstantPriceLargeAmounts = false;
   readonly needWrapNative = true;
 
-  readonly directSwapIface = new Interface(DirectSwapABI);
-
   intervalTask?: NodeJS.Timeout;
 
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
@@ -123,7 +113,7 @@ export class UniswapV3
     // To receive revert reasons
     this.dexHelper.web3Provider.eth.handleRevert = false;
 
-    // Normalize once all config addresses and use across all scenarios
+    // Normalise once all config addresses and use across all scenarios
     this.config = this._toLowerForAllConfigAddresses();
 
     this.notExistingPoolSetKey =
@@ -459,7 +449,6 @@ export class UniswapV3
               fee: pool.feeCodeAsString,
             },
           ],
-          exchange: pool.poolAddress,
         },
         poolIdentifier: this.getPoolIdentifier(
           pool.token0,
@@ -742,130 +731,6 @@ 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,
@@ -880,7 +745,7 @@ export class UniswapV3
         : UniswapV3Functions.exactOutput;
 
     const path = this._encodePath(data.path, side);
-    const swapFunctionParams: UniswapV3SimpleSwapParams =
+    const swapFunctionParams: UniswapV3Param =
       side === SwapSide.SELL
         ? {
             recipient: this.augustusAddress,

package/src/dex/woo-fi-v2/config.ts

@@ -6,7 +6,7 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
   WooFiV2: {
     [Network.OPTIMISM]: {
       wooPPV2Address: '0xd1778F9DF3eee5473A9640f13682e3846f61fEbC',
-      wooOracleV2Address: '0xd589484d3A27B7Ce5C2C7F829EB2e1D163f95817',
+      wooOracleV2Address: '0x464959aD46e64046B891F562cFF202a465D522F3',
       integrationHelperAddress: '0x96329d66074EB8386Ae8bFD6698B2E3FDA87e15E',
       // USDC
       quoteToken: {
@@ -16,7 +16,7 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
     },
     [Network.BSC]: {
       wooPPV2Address: '0x59dE3B49314Bf5067719364A2Cb43e8525ab93FA',
-      wooOracleV2Address: '0x72dc7fa5eeb901a34173C874A7333c8d1b34bca9',
+      wooOracleV2Address: '0x4B11B9BfAafA840c436a1ddDc13D3738C8ebfD62',
       integrationHelperAddress: '0xAA9c15cd603428cA8ddD45e933F8EfE3Afbcc173',
       // USDT
       quoteToken: {
@@ -26,7 +26,7 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
     },
     [Network.POLYGON]: {
       wooPPV2Address: '0x7081A38158BD050Ae4a86e38E0225Bc281887d7E',
-      wooOracleV2Address: '0x31aE608cBadD1214D6A3d5dcf49E45Fb18E2a48E',
+      wooOracleV2Address: '0xeFF23B4bE1091b53205E35f3AfCD9C7182bf3062',
       integrationHelperAddress: '0x7Ba560eB735AbDCf9a3a5692272652A0cc81850d',
       // USDC
       quoteToken: {
@@ -36,7 +36,7 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
     },
     [Network.FANTOM]: {
       wooPPV2Address: '0x286ab107c5E9083dBed35A2B5fb0242538F4f9bf',
-      wooOracleV2Address: '0xB1d022F8F3e43868DaaDfa7040e63781C16aB4A6',
+      wooOracleV2Address: '0x8840e26e0ebf7D100A0644DD8576DC62B03cbf04',
       integrationHelperAddress: '0x6641959FE5EED7166F2254cF04b0d20c96776D9A',
       // USDC
       quoteToken: {
@@ -46,7 +46,7 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
     },
     [Network.ARBITRUM]: {
       wooPPV2Address: '0xeFF23B4bE1091b53205E35f3AfCD9C7182bf3062',
-      wooOracleV2Address: '0x73504eaCB100c7576146618DC306c97454CB3620',
+      wooOracleV2Address: '0x37a9dE70b6734dFCA54395D8061d9411D9910739',
       integrationHelperAddress: '0x28D2B949024FE50627f1EbC5f0Ca3Ca721148E40',
       // USDC
       quoteToken: {
@@ -56,7 +56,7 @@ export const WooFiV2Config: DexConfigMap<DexParams> = {
     },
     [Network.AVALANCHE]: {
       wooPPV2Address: '0x3b3E4b4741e91aF52d0e9ad8660573E951c88524',
-      wooOracleV2Address: '0xc13843aE0D2C5ca9E0EfB93a78828446D8173d19',
+      wooOracleV2Address: '0x9ACA557590F5020BDA4Ba63065Fc3A1253Bf8000',
       integrationHelperAddress: '0x020630613E296c3E9b06186f630D1bF97A2B6Ad1',
       // USDC
       quoteToken: {

package/src/dex/zerox/index.ts

@@ -269,16 +269,9 @@ 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,8 +17,6 @@ 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(
@@ -207,8 +205,6 @@ 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(
@@ -238,9 +234,6 @@ export class LocalParaswapSDK implements IParaSwapSDK {
                         {
                           slippageFactor,
                           txOrigin: userAddress,
-                          isDirectMethod: DirectContractMethods.includes(
-                            contractMethod as ContractMethod,
-                          ),
                         },
                       );
 
@@ -271,7 +264,7 @@ export class LocalParaswapSDK implements IParaSwapSDK {
       partnerAddress: NULL_ADDRESS,
       partnerFeePercent: '0',
       deadline: deadline.toString(),
-      uuid: uuid(),
+      uuid: '00000000-0000-0000-0000-000000000000',
     });
   }
 }