@paraswap/dex-lib 3.0.6 → 3.2.5-return-amount-pos.5

package/src/dex/pancakeswap-v3/pancakeswap-v3-pool.ts

@@ -124,6 +124,14 @@ export class PancakeSwapV3EventPool extends StatefulEventSubscriber<PoolState> {
     await super.initialize(blockNumber, options);
   }
 
+  protected getPoolIdentifierData() {
+    return {
+      token0: this.token0,
+      token1: this.token1,
+      fee: this.feeCode,
+    };
+  }
+
   protected async processBlockLogs(
     state: DeepReadonly<PoolState>,
     logs: Readonly<Log>[],

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

@@ -61,6 +61,7 @@ import {
   OnPoolCreatedCallback,
   PancakeswapV3Factory,
 } from './pancakeswap-v3-factory';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 type PoolPairsInfo = {
   token0: Address;
@@ -68,6 +69,8 @@ type PoolPairsInfo = {
   fee: string;
 };
 
+const PoolsRegistryHashKey = `${CACHE_PREFIX}_poolsRegistry`;
+
 const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
 const PANCAKESWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 24 * 60 * 60 * 1000; // Once in a day
 const PANCAKESWAPV3_QUOTE_GASLIMIT = 200_000;
@@ -86,7 +89,13 @@ export class PancakeswapV3
   intervalTask?: NodeJS.Timeout;
 
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(_.pick(PancakeswapV3Config, ['PancakeswapV3']));
+    getDexKeysWithNetwork(
+      _.pick(PancakeswapV3Config, [
+        'PancakeswapV3',
+        'DackieSwapV3',
+        'SwapBasedV3',
+      ]),
+    );
 
   logger: Logger;
 
@@ -251,16 +260,6 @@ export class PancakeswapV3
           null;
         return null;
       }
-
-      await this.dexHelper.cache.hset(
-        this.dexmapKey,
-        key,
-        JSON.stringify({
-          token0,
-          token1,
-          fee: fee.toString(),
-        }),
-      );
     }
 
     this.logger.trace(`starting to listen to new pool: ${key}`);
@@ -340,10 +339,13 @@ export class PancakeswapV3
   }
 
   async addMasterPool(poolKey: string, blockNumber: number): Promise<boolean> {
-    const _pairs = await this.dexHelper.cache.hget(this.dexmapKey, poolKey);
+    const _pairs = await this.dexHelper.cache.hget(
+      PoolsRegistryHashKey,
+      `${this.cacheStateKey}_${poolKey}`,
+    );
     if (!_pairs) {
       this.logger.warn(
-        `did not find poolConfig in for key ${this.dexmapKey} ${poolKey}`,
+        `did not find poolConfig in for key ${PoolsRegistryHashKey} ${this.cacheStateKey}_${poolKey}`,
       );
       return false;
     }
@@ -893,6 +895,14 @@ export class PancakeswapV3
       dexFuncHasRecipient: true,
       exchangeData,
       targetExchange: this.config.router,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.routerIface,
+              swapFunction,
+              'amountOut',
+            )
+          : undefined,
     };
   }
 
@@ -900,6 +910,8 @@ export class PancakeswapV3
     tokenAddress: Address,
     limit: number,
   ): Promise<PoolLiquidity[]> {
+    if (!this.config.subgraphURL) return [];
+
     const _tokenAddress = tokenAddress.toLowerCase();
 
     const res = await this._querySubgraph(
@@ -1072,6 +1084,8 @@ export class PancakeswapV3
     variables: Object,
     timeout = 30000,
   ) {
+    if (!this.config.subgraphURL) return [];
+
     try {
       const res = await this.dexHelper.httpRequest.post(
         this.config.subgraphURL,

package/src/dex/paraswap-limit-orders/paraswap-limit-orders.ts

@@ -398,6 +398,7 @@ export class ParaSwapLimitOrders
       dexFuncHasRecipient: true,
       exchangeData: swapData,
       targetExchange: this.augustusRFQAddress,
+      returnAmountPos: undefined,
     };
   }
 

package/src/dex/platypus/platypus.ts

@@ -38,6 +38,7 @@ import PoolABI from '../../abi/platypus/pool.json';
 import AvaxPoolABI from '../../abi/platypus/avax-pool.json';
 import AssetABI from '../../abi/platypus/asset.json';
 import OracleABI from '../../abi/platypus/oracle.json';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
   static readonly erc20Interface = new Interface(ERC20ABI);
@@ -497,22 +498,34 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
     data: PlatypusData,
     side: SwapSide,
   ): DexExchangeParam {
+    const iface = isETHAddress(srcToken)
+      ? Platypus.avaxPoolInterface
+      : isETHAddress(destToken)
+      ? Platypus.avaxPoolInterface
+      : Platypus.poolInterface;
+
+    const swapFunction = isETHAddress(srcToken)
+      ? 'swapFromETH'
+      : isETHAddress(destToken)
+      ? 'swapToETH'
+      : 'swap';
+
     const swapData = isETHAddress(srcToken)
-      ? Platypus.avaxPoolInterface.encodeFunctionData('swapFromETH', [
+      ? iface.encodeFunctionData(swapFunction, [
           destToken,
           1,
           recipient,
           getLocalDeadlineAsFriendlyPlaceholder(),
         ])
       : isETHAddress(destToken)
-      ? Platypus.avaxPoolInterface.encodeFunctionData('swapToETH', [
+      ? iface.encodeFunctionData(swapFunction, [
           srcToken,
           srcAmount,
           1,
           recipient,
           getLocalDeadlineAsFriendlyPlaceholder(),
         ])
-      : Platypus.poolInterface.encodeFunctionData('swap', [
+      : iface.encodeFunctionData(swapFunction, [
           srcToken,
           destToken,
           srcAmount,
@@ -526,6 +539,10 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
       dexFuncHasRecipient: true,
       exchangeData: swapData,
       targetExchange: data.pool,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(iface, swapFunction, 'actualToAmount')
+          : undefined,
     };
   }
 

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

@@ -181,6 +181,7 @@ export class PolygonMigrator
       dexFuncHasRecipient: false,
       exchangeData: swapData,
       targetExchange: this.migratorAddress,
+      returnAmountPos: undefined,
     };
   }
 

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

@@ -24,6 +24,7 @@ import { QuickPerpsConfig, Adapters } from './config';
 import { Vault } from './vault';
 import ERC20ABI from '../../abi/erc20.json';
 import { solidityPack } from 'ethers/lib/utils';
+import { extractReturnAmountPosition } from '../../executor/utils';
 
 const QuickPerpsGasCost = 300 * 1000;
 
@@ -228,7 +229,9 @@ export class QuickPerps extends SimpleExchange implements IDex<QuickPerpsData> {
     data: QuickPerpsData,
     side: SwapSide,
   ): DexExchangeParam {
-    const swapData = Vault.interface.encodeFunctionData('swap', [
+    const iface = Vault.interface;
+    const functionName = 'swap';
+    const swapData = iface.encodeFunctionData(functionName, [
       srcToken,
       destToken,
       recipient,
@@ -241,6 +244,13 @@ export class QuickPerps extends SimpleExchange implements IDex<QuickPerpsData> {
       targetExchange: this.params.vault,
       swappedAmountNotPresentInExchangeData: true,
       transferSrcTokenBeforeSwap: this.params.vault,
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              iface,
+              functionName,
+            )
+          : undefined,
     };
   }
 

package/src/dex/simple-exchange.ts

@@ -47,7 +47,6 @@ export class SimpleExchange {
   protected augustusV6Interface: Interface;
 
   protected network: number;
-  protected dexmapKey: string;
 
   readonly cacheStateKey: string;
 
@@ -65,9 +64,6 @@ export class SimpleExchange {
     this.augustusInterface = new Interface(augustusABI);
     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();
   }

package/src/dex/smoothy/smoothy.ts

@@ -104,6 +104,7 @@ export class Smoothy
       dexFuncHasRecipient: false,
       exchangeData: swapData,
       targetExchange: exchange,
+      returnAmountPos: undefined,
     };
   }
 }

package/src/dex/solidly/config.ts

@@ -159,6 +159,20 @@ export const SolidlyConfig: DexConfigMap<DexParams> = {
       feeCode: 0,
     },
   },
+  PharaohV1: {
+    [Network.AVALANCHE]: {
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/66247/pharaoh-legacy/version/latest',
+      factoryAddress: '0xAAA16c016BF556fcD620328f0759252E29b1AB57',
+      router: '0x609AcD8Fc955Dd7E744c7DFFc9930a7A6654DE43',
+      initCode:
+        '0xbf2404274de2b11f05e5aebd49e508de933034cb5fa2d0ac3de8cbd4bcef47dc',
+      poolGasCost: 180 * 1000,
+      stableFee: 5,
+      volatileFee: 25,
+      feeCode: 0,
+    },
+  },
   Equalizer: {
     [Network.FANTOM]: {
       factoryAddress: '0xc6366EFD0AF1d09171fe0EBF32c7943BB310832a',

package/src/dex/solidly/forks-override/pharaohV1.ts

@@ -0,0 +1,10 @@
+import { Network } from '../../../constants';
+import { getDexKeysWithNetwork } from '../../../utils';
+import { SolidlyConfig } from '../config';
+import _ from 'lodash';
+import { Ramses } from './ramses';
+
+export class PharaohV1 extends Ramses {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(SolidlyConfig, ['PharaohV1']));
+}

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

@@ -1367,6 +1367,27 @@ describe('Solidly E2E', () => {
         });
       });
     });
+
+    describe('PharaohV1', () => {
+      const dexKey = 'PharaohV1';
+
+      const tokenASymbol: string = 'USDC';
+      const tokenBSymbol: string = 'WAVAX';
+
+      const tokenAAmount: string = '100000';
+      const tokenBAmount: string = '100000000000000000';
+      const nativeTokenAmount = '100000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
   });
 
   describe('Arbitrum', () => {

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

@@ -19,6 +19,7 @@ import { VelodromeV2 } from './forks-override/velodromeV2';
 import { Equalizer } from './forks-override/equalizer';
 import { Velocimeter } from './forks-override/velocimeter';
 import { Usdfi } from './forks-override/usdfi';
+import { PharaohV1 } from './forks-override/pharaohV1';
 
 const amounts18 = [0n, BI_POWS[18], 2000000000000000000n];
 const amounts6 = [0n, BI_POWS[6], 2000000n];
@@ -1443,6 +1444,148 @@ describe('Solidly integration tests', () => {
     });
   });
 
+  describe('Avalanche', () => {
+    const network = Network.AVALANCHE;
+    const dexHelper = new DummyDexHelper(network);
+    const checkOnChainPricing = constructCheckOnChainPricing(dexHelper);
+
+    describe('PharaohV1', function () {
+      const dexKey = 'PharaohV1';
+      const pharaohV1 = new PharaohV1(network, dexKey, dexHelper);
+
+      describe('UniswapV2 like pool', function () {
+        const TokenASymbol = 'USDC';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'WAVAX';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts18;
+
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await pharaohV1.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          console.log('AMOUNTS: ', amounts);
+
+          const poolPrices = await pharaohV1.getPricesVolume(
+            tokenA,
+            tokenB,
+            amounts,
+            SwapSide.SELL,
+            blocknumber,
+            pools,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+            util.inspect(poolPrices, false, null, true),
+          );
+
+          expect(poolPrices).not.toBeNull();
+          checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+          // Check if onchain pricing equals to calculated ones
+
+          for (const poolPrice of poolPrices || []) {
+            await checkOnChainPricing(
+              pharaohV1,
+              'getAmountOut',
+              blocknumber,
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+
+        it('getTopPoolsForToken', async function () {
+          const poolLiquidity = await pharaohV1.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 pharaohV1.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await pharaohV1.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 poolPrice of poolPrices || []) {
+            await checkOnChainPricing(
+              pharaohV1,
+              'getAmountOut',
+              blocknumber,
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+
+        it('getTopPoolsForToken', async function () {
+          const poolLiquidity = await pharaohV1.getTopPoolsForToken(
+            tokenA.address,
+            10,
+          );
+          console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+          checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+        });
+      });
+    });
+  });
+
   describe('Optimism', () => {
     const network = Network.OPTIMISM;
     const dexHelper = new DummyDexHelper(network);

package/src/dex/solidly/solidly.ts

@@ -88,6 +88,7 @@ export class Solidly extends UniswapV2 {
         'Equalizer',
         'Velocimeter',
         'Usdfi',
+        'PharaohV1',
       ]),
     );
 
@@ -682,6 +683,7 @@ export class Solidly extends UniswapV2 {
       transferSrcTokenBeforeSwap: data.isFeeTokenInRoute
         ? undefined
         : data.pools[0].address,
+      returnAmountPos: undefined,
     };
   }
 }

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

@@ -44,7 +44,6 @@ export const SolidlyV3Config: DexConfigMap<DexParams> = {
   SolidlyV3: {
     [Network.MAINNET]: {
       factory: '0x70Fe4a44EA505cFa3A57b95cF2862D4fd5F0f687',
-      quoter: '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
       supportedTickSpacings: SUPPORTED_TICK_SPACINGS,
       stateMulticall: '0xb229563028302AA693EEaD62F80CC331aEDE4e26',
       chunksCount: 10,
@@ -53,6 +52,17 @@ export const SolidlyV3Config: DexConfigMap<DexParams> = {
       subgraphURL:
         'https://api.thegraph.com/subgraphs/name/solidlylabs/solidly-v3',
     },
+    [Network.FANTOM]: {
+      factory: '0x70Fe4a44EA505cFa3A57b95cF2862D4fd5F0f687',
+      supportedTickSpacings: SUPPORTED_TICK_SPACINGS,
+      stateMulticall: '0x000c5dd531b3e2327c0E3a382bC8B21a284E6F61',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash:
+        '0xe9b68c5f77858eecac2e651646e208175e9b1359d68d0e14fc69f8c54e5010bf',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/solidlylabs/solidly-v3-fantom',
+    },
   },
 };
 
@@ -61,4 +71,8 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'Adapter04', index: 7 }],
     [SwapSide.BUY]: [{ name: 'BuyAdapter02', index: 3 }],
   },
+  [Network.FANTOM]: {
+    [SwapSide.SELL]: [{ name: 'FantomAdapter02', index: 1 }],
+    [SwapSide.BUY]: [{ name: 'FantomBuyAdapter', index: 5 }],
+  },
 };

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

@@ -123,4 +123,37 @@ describe('SolidlyV3 E2E', () => {
 
     testForNetwork(network, dexKey, pairs);
   });
+
+  describe('Fantom', () => {
+    const network = Network.FANTOM;
+
+    const pairs = [
+      [
+        {
+          name: NativeTokenSymbols[network],
+          sellAmount: '100000000000000000',
+          buyAmount: '1000000000',
+        },
+        {
+          name: 'SOLID',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000',
+        },
+      ],
+      [
+        {
+          name: 'WFTM',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000',
+        },
+        {
+          name: 'SOLID',
+          sellAmount: '1000000000000000000',
+          buyAmount: '1000000000',
+        },
+      ],
+    ];
+
+    testForNetwork(network, dexKey, pairs);
+  });
 });

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

@@ -38,7 +38,14 @@ export class SolidlyV3Factory extends StatefulEventSubscriber<FactoryState> {
     protected readonly onPoolCreated: OnPoolCreatedCallback,
     mapKey: string = '',
   ) {
-    super(parentName, `${parentName} Factory`, dexHelper, logger, true, mapKey);
+    super(
+      parentName,
+      `${parentName} Factory`,
+      dexHelper,
+      logger,
+      false,
+      mapKey,
+    );
 
     this.addressesSubscribed = [factoryAddress];
 

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

@@ -128,6 +128,14 @@ export class SolidlyV3EventPool extends StatefulEventSubscriber<PoolState> {
     await super.initialize(blockNumber, options);
   }
 
+  protected getPoolIdentifierData() {
+    return {
+      token0: this.token0,
+      token1: this.token1,
+      fee: this.tickSpacing.toString(),
+    };
+  }
+
   protected async processBlockLogs(
     state: DeepReadonly<PoolState>,
     logs: Readonly<Log>[],

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

@@ -34,7 +34,6 @@ import {
 } from '../simple-exchange';
 import { SolidlyV3Config, Adapters, PoolsToPreload } from './config';
 import { SolidlyV3EventPool } from './solidly-v3-pool';
-import UniswapV3QuoterV2ABI from '../../abi/uniswap-v3/UniswapV3QuoterV2.abi.json';
 import DirectSwapABI from '../../abi/DirectSwap.json';
 import SolidlyV3StateMulticallABI from '../../abi/solidly-v3/SolidlyV3StateMulticall.abi.json';
 import SolidlyV3PoolABI from '../../abi/solidly-v3/SolidlyV3Pool.abi.json';
@@ -48,7 +47,6 @@ 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';
-import { OptimalSwapExchange } from '@paraswap/core';
 import { TickMath } from './contract-math/TickMath';
 import { OnPoolCreatedCallback, SolidlyV3Factory } from './solidly-v3-factory';
 
@@ -58,6 +56,8 @@ type PoolPairsInfo = {
   fee: string;
 };
 
+const PoolsRegistryHashKey = `${CACHE_PREFIX}_poolsRegistry`;
+
 const UNISWAPV3_CLEAN_NOT_EXISTING_POOL_TTL_MS = 60 * 60 * 24 * 1000; // 24 hours
 const UNISWAPV3_CLEAN_NOT_EXISTING_POOL_INTERVAL_MS = 30 * 60 * 1000; // Once in 30 minutes
 
@@ -92,7 +92,6 @@ export class SolidlyV3
     protected dexHelper: IDexHelper,
     protected adapters = Adapters[network] || {},
     readonly poolIface = new Interface(SolidlyV3PoolABI),
-    readonly quoterIface = new Interface(UniswapV3QuoterV2ABI),
     protected config = SolidlyV3Config[dexKey][network],
     protected poolsToPreload = PoolsToPreload[dexKey]?.[network] || [],
   ) {
@@ -259,16 +258,6 @@ export class SolidlyV3
         ] = null;
         return null;
       }
-
-      await this.dexHelper.cache.hset(
-        this.dexmapKey,
-        key,
-        JSON.stringify({
-          token0,
-          token1,
-          fee: tickSpacing.toString(),
-        }),
-      );
     }
 
     this.logger.trace(`starting to listen to new pool: ${key}`);
@@ -345,10 +334,13 @@ export class SolidlyV3
   }
 
   async addMasterPool(poolKey: string, blockNumber: number): Promise<boolean> {
-    const _pairs = await this.dexHelper.cache.hget(this.dexmapKey, poolKey);
+    const _pairs = await this.dexHelper.cache.hget(
+      PoolsRegistryHashKey,
+      `${this.cacheStateKey}_${poolKey}`,
+    );
     if (!_pairs) {
       this.logger.warn(
-        `did not find poolConfig in for key ${this.dexmapKey} ${poolKey}`,
+        `did not find poolConfig in for key ${PoolsRegistryHashKey} ${this.cacheStateKey}_${poolKey}`,
       );
       return false;
     }
@@ -732,6 +724,7 @@ export class SolidlyV3
       dexFuncHasRecipient: true,
       exchangeData: swapData,
       targetExchange: data.poolAddress,
+      returnAmountPos: undefined,
     };
   }
 
@@ -839,7 +832,6 @@ export class SolidlyV3
   private _toLowerForAllConfigAddresses() {
     // If new config property will be added, the TS will throw compile error
     const newConfig: DexParams = {
-      quoter: this.config.quoter.toLowerCase(),
       factory: this.config.factory.toLowerCase(),
       supportedTickSpacings: this.config.supportedTickSpacings,
       stateMulticall: this.config.stateMulticall.toLowerCase(),

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

@@ -46,7 +46,6 @@ export type DecodeStateMultiCallFunc = (
 ) => DecodedStateMultiCallResultWithRelativeBitmaps;
 
 export type DexParams = {
-  quoter: Address;
   factory: Address;
   stateMulticall: Address;
   supportedTickSpacings: bigint[];