@paraswap/dex-lib 4.1.7-pub-sub.2 → 4.1.7-pub-sub.4

package/src/dex/generic-rfq/rate-fetcher.ts

@@ -46,7 +46,6 @@ export const reversePrice = (price: PriceAndAmountBigNumber) =>
     price[1].times(price[0]),
   ] as PriceAndAmountBigNumber;
 
-const logPrefix = 'RateFetched[pub_sub]';
 export class RateFetcher {
   private tokensFetcher: Fetcher<TokensResponse>;
   private pairsFetcher: Fetcher<PairsResponse>;
@@ -168,7 +167,6 @@ export class RateFetcher {
   }
 
   async initialize() {
-    this.logger.info(`${logPrefix} Initializing rate fetcher`);
     const isContract = await isContractAddress(
       this.dexHelper.web3Provider,
       this.config.maker,
@@ -181,10 +179,8 @@ export class RateFetcher {
     }
 
     if (this.dexHelper.config.isSlave) {
-      this.logger.info(`${logPrefix} Subscribing to prices pubsub`);
       this.pricesPubSub.subscribe();
       if (this.blacklistPubSub) {
-        this.logger.info(`${logPrefix} Subscribing to blacklist pubsub`);
         const initSet = await this.dexHelper.cache.smembers(
           this.blackListCacheKey,
         );
@@ -194,7 +190,6 @@ export class RateFetcher {
   }
 
   start() {
-    this.logger.info(`${logPrefix} Starting rate fetcher`);
     this.tokensFetcher.startPolling();
     this.rateFetcher.startPolling();
     this.pairsFetcher.startPolling();
@@ -204,7 +199,6 @@ export class RateFetcher {
   }
 
   stop() {
-    this.logger.info(`${logPrefix} Stopping rate fetcher`);
     this.tokensFetcher.stopPolling();
     this.pairsFetcher.stopPolling();
     this.rateFetcher.stopPolling();
@@ -215,10 +209,6 @@ export class RateFetcher {
   }
 
   private handleTokensResponse(data: TokensResponse) {
-    this.logger.info(
-      `${logPrefix} Handling tokens response, tokens: `,
-      Object.keys(data.tokens).length,
-    );
     for (const tokenName of Object.keys(data.tokens)) {
       const token = data.tokens[tokenName];
       token.address = token.address.toLowerCase();
@@ -236,10 +226,6 @@ export class RateFetcher {
   }
 
   private handlePairsResponse(resp: PairsResponse) {
-    this.logger.info(
-      `${logPrefix} Handling pairs response, pairs: `,
-      Object.keys(resp.pairs).length,
-    );
     this.pairs = {};
 
     const pairs: PairMap = {};
@@ -251,19 +237,11 @@ export class RateFetcher {
   }
 
   private handleBlackListResponse(resp: BlackListResponse) {
-    this.logger.info(
-      `${logPrefix} Handling blacklist response, blacklist length: `,
-      resp.blacklist.length,
-    );
     for (const address of resp.blacklist) {
       this.dexHelper.cache.sadd(this.blackListCacheKey, address.toLowerCase());
     }
 
     if (this.blacklistPubSub) {
-      this.logger.info(
-        `${logPrefix} Publishing blacklist to pubsub, blacklist length: `,
-        resp.blacklist.length,
-      );
       this.blacklistPubSub.publish(resp.blacklist);
     }
   }
@@ -276,10 +254,6 @@ export class RateFetcher {
   }
 
   private handleRatesResponse(resp: RatesResponse) {
-    this.logger.info(
-      `${logPrefix} Handling rates response, prices length: `,
-      Object.keys(resp.prices).length,
-    );
     const pubSubData: Record<string, unknown> = {};
     const ttl = this.config.rateConfig.dataTTLS;
     const pairs = this.pairs;
@@ -395,10 +369,6 @@ export class RateFetcher {
 
   public async getAvailablePairs(): Promise<string[]> {
     const pairs = await this.pricesPubSub.getAndCache<string[]>(`pairs`);
-    this.logger.info(
-      `${logPrefix} Getting available pairs, pairs: `,
-      pairs?.length,
-    );
     if (!pairs) {
       return [];
     }

package/src/dex/hashflow/constants.ts

@@ -4,11 +4,11 @@ export const HASHFLOW_BLACKLIST_TTL_S = 60 * 60 * 24 * 7; // 7 days
 
 export const HASHFLOW_MM_RESTRICT_TTL_S = 60 * 60;
 
-export const HASHFLOW_PRICES_CACHES_TTL_S = 3;
+export const HASHFLOW_PRICES_CACHES_TTL_S = 5;
 
 export const HASHFLOW_MARKET_MAKERS_CACHES_TTL_S = 30;
 
-export const HASHFLOW_API_PRICES_POLLING_INTERVAL_MS = 1000;
+export const HASHFLOW_API_PRICES_POLLING_INTERVAL_MS = 2000;
 
 export const HASHFLOW_API_MARKET_MAKERS_POLLING_INTERVAL_MS = 28 * 1000; // 28 secs
 

package/src/dex/hashflow/hashflow-gas-estimation.test.ts

@@ -0,0 +1,30 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Hashflow Gas Estimation', () => {
+  const dexKey = 'Hashflow';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    // todo: fix tx build
+    it('tradeRFQT', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/hashflow/hashflow.ts

@@ -1,10 +1,6 @@
 import { ChainId } from '@hashflow/sdk';
 import { Chain, ChainType, HashflowApi } from '@hashflow/taker-js';
-import {
-  MarketMakersResponse,
-  PriceLevelsResponse,
-  RfqResponse,
-} from '@hashflow/taker-js/dist/types/rest';
+import { RfqResponse } from '@hashflow/taker-js/dist/types/rest';
 import BigNumber from 'bignumber.js';
 import { Interface } from 'ethers/lib/utils';
 import { assert } from 'ts-essentials';
@@ -145,7 +141,6 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
             },
             headers: { Authorization: this.hashFlowAuthToken },
           },
-          getCachedMarketMakers: this.getCachedMarketMakers.bind(this),
           filterMarketMakers: this.getFilteredMarketMakers.bind(this),
           pricesCacheKey: this.pricesCacheKey,
           pricesCacheTTLSecs: HASHFLOW_PRICES_CACHES_TTL_S,
@@ -157,9 +152,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
   }
 
   async initializePricing(blockNumber: number): Promise<void> {
-    if (!this.dexHelper.config.isSlave) {
-      this.rateFetcher.start();
-    }
+    this.rateFetcher.start();
 
     return;
   }
@@ -198,7 +191,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
       return [];
     }
 
-    const levels = (await this.getCachedLevels()) || {};
+    const levels = (await this.rateFetcher.getCachedLevels()) || {};
     const makers = Object.keys(levels);
 
     return makers
@@ -381,32 +374,6 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     return undefined;
   }
 
-  async getCachedMarketMakers(): Promise<
-    MarketMakersResponse['marketMakers'] | null
-  > {
-    const cachedMarketMakers = await this.dexHelper.cache.rawget(
-      this.marketMakersCacheKey,
-    );
-
-    if (cachedMarketMakers) {
-      return JSON.parse(
-        cachedMarketMakers,
-      ) as MarketMakersResponse['marketMakers'];
-    }
-
-    return null;
-  }
-
-  async getCachedLevels(): Promise<PriceLevelsResponse['levels'] | null> {
-    const cachedLevels = await this.dexHelper.cache.rawget(this.pricesCacheKey);
-
-    if (cachedLevels) {
-      return JSON.parse(cachedLevels) as PriceLevelsResponse['levels'];
-    }
-
-    return null;
-  }
-
   async getPricesVolume(
     srcToken: Token,
     destToken: Token,
@@ -434,7 +401,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
 
       const marketMakersToUse = pools.map(p => p.split(`${prefix}_`).pop());
 
-      const levelsMap = (await this.getCachedLevels()) || {};
+      const levelsMap = (await this.rateFetcher.getCachedLevels()) || {};
 
       Object.keys(levelsMap).forEach(mmKey => {
         if (!marketMakersToUse.includes(mmKey)) {
@@ -715,7 +682,7 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
         this.logger.warn(
           `${this.dexKey}-${this.network}: Encountered restricted user=${options.userAddress}. Adding to local blacklist cache`,
         );
-        await this.setBlacklist(options.userAddress);
+        await this.rateFetcher.setBlacklist(options.userAddress);
       } else {
         if (e instanceof TooStrictSlippageCheckError) {
           this.logger.warn(
@@ -911,33 +878,6 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
     };
   }
 
-  getBlackListKey(address: Address) {
-    return `blacklist_${address}`.toLowerCase();
-  }
-
-  async isBlacklisted(txOrigin: Address): Promise<boolean> {
-    const result = await this.dexHelper.cache.get(
-      this.dexKey,
-      this.network,
-      this.getBlackListKey(txOrigin),
-    );
-    return result === 'blacklisted';
-  }
-
-  async setBlacklist(
-    txOrigin: Address,
-    ttl: number = HASHFLOW_BLACKLIST_TTL_S,
-  ) {
-    await this.dexHelper.cache.setex(
-      this.dexKey,
-      this.network,
-      this.getBlackListKey(txOrigin),
-      ttl,
-      'blacklisted',
-    );
-    return true;
-  }
-
   async getSimpleParam(
     srcToken: string,
     destToken: string,
@@ -1058,9 +998,9 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
       .wrapETH(tokenAddress)
       .toLowerCase();
 
-    const makers = (await this.getCachedMarketMakers()) || [];
+    const makers = (await this.rateFetcher.getCachedMarketMakers()) || [];
     const filteredMakers = await this.getFilteredMarketMakers(makers);
-    const pLevels = (await this.getCachedLevels()) || {};
+    const pLevels = (await this.rateFetcher.getCachedLevels()) || {};
 
     let baseToken: Token | undefined = undefined;
     // TODO: Improve efficiency of this part. Quite inefficient way to determine
@@ -1120,4 +1060,8 @@ export class Hashflow extends SimpleExchange implements IDex<HashflowData> {
       this.rateFetcher.stop();
     }
   }
+
+  async isBlacklisted(txOrigin: Address): Promise<boolean> {
+    return this.rateFetcher.isBlacklisted(txOrigin);
+  }
 }

package/src/dex/hashflow/rate-fetcher.ts

@@ -1,17 +1,24 @@
+import {
+  MarketMakersResponse,
+  PriceLevelsResponse,
+} from '@hashflow/taker-js/dist/types/rest';
 import { Network } from '../../constants';
 import { IDexHelper } from '../../dex-helper';
 import { Fetcher, SkippingRequest } from '../../lib/fetcher/fetcher';
 import { validateAndCast } from '../../lib/validators';
-import { Logger } from '../../types';
+import { Address, Logger } from '../../types';
 import {
   HashflowMarketMakersResponse,
   HashflowRateFetcherConfig,
   HashflowRatesResponse,
 } from './types';
 import { marketMakersValidator, pricesResponseValidator } from './validators';
+import { HASHFLOW_BLACKLIST_TTL_S } from './constants';
+import { ExpKeyValuePubSub, NonExpSetPubSub } from '../../lib/pub-sub';
 
 export class RateFetcher {
   private rateFetcher: Fetcher<HashflowRatesResponse>;
+  private ratePubSub: ExpKeyValuePubSub;
   private pricesCacheKey: string;
   private pricesCacheTTL: number;
 
@@ -19,6 +26,8 @@ export class RateFetcher {
   private marketMakersCacheKey: string;
   private marketMakersCacheTTL: number;
 
+  private blacklistedPubSub: NonExpSetPubSub;
+
   constructor(
     private dexHelper: IDexHelper,
     private dexKey: string,
@@ -48,16 +57,18 @@ export class RateFetcher {
       logger,
     );
 
+    this.ratePubSub = new ExpKeyValuePubSub(dexHelper, dexKey, 'rates');
+
     this.rateFetcher = new Fetcher<HashflowRatesResponse>(
       dexHelper.httpRequest,
       {
         info: {
           requestOptions: config.rateConfig.pricesReqParams,
           requestFunc: async options => {
-            const { filterMarketMakers, getCachedMarketMakers } =
-              config.rateConfig;
+            const { filterMarketMakers } = config.rateConfig;
 
-            const cachedMarketMakers = (await getCachedMarketMakers()) || [];
+            const cachedMarketMakers =
+              (await this.getCachedMarketMakers()) || [];
             const filteredMarketMakers = await filterMarketMakers(
               cachedMarketMakers,
             );
@@ -86,11 +97,24 @@ export class RateFetcher {
       config.rateConfig.pricesIntervalMs,
       logger,
     );
+
+    this.blacklistedPubSub = new NonExpSetPubSub(
+      dexHelper,
+      dexKey,
+      'blacklisted',
+    );
   }
 
-  start() {
-    this.marketMakersFetcher.startPolling();
-    this.rateFetcher.startPolling();
+  async start() {
+    if (!this.dexHelper.config.isSlave) {
+      this.marketMakersFetcher.startPolling();
+      this.rateFetcher.startPolling();
+    } else {
+      this.ratePubSub.subscribe();
+
+      const allBlacklisted = await this.getAllBlacklisted();
+      this.blacklistedPubSub.initializeAndSubscribe(allBlacklisted);
+    }
   }
 
   stop() {
@@ -109,10 +133,84 @@ export class RateFetcher {
 
   private handleRatesResponse(resp: HashflowRatesResponse): void {
     const { levels } = resp;
-    this.dexHelper.cache.rawset(
+    this.dexHelper.cache.setex(
+      this.dexKey,
+      this.network,
       this.pricesCacheKey,
+      this.pricesCacheTTL,
       JSON.stringify(levels),
+    );
+
+    this.ratePubSub.publish(
+      { [this.pricesCacheKey]: levels },
       this.pricesCacheTTL,
     );
   }
+
+  async getCachedMarketMakers(): Promise<
+    MarketMakersResponse['marketMakers'] | null
+  > {
+    const cachedMarketMakers = await this.dexHelper.cache.rawget(
+      this.marketMakersCacheKey,
+    );
+
+    if (cachedMarketMakers) {
+      return JSON.parse(
+        cachedMarketMakers,
+      ) as MarketMakersResponse['marketMakers'];
+    }
+
+    return null;
+  }
+
+  async getCachedLevels(): Promise<PriceLevelsResponse['levels'] | null> {
+    const cachedLevels = await this.ratePubSub.getAndCache(this.pricesCacheKey);
+
+    if (cachedLevels) {
+      return cachedLevels as PriceLevelsResponse['levels'];
+    }
+
+    return null;
+  }
+
+  async isBlacklisted(txOrigin: Address): Promise<boolean> {
+    return this.blacklistedPubSub.has(txOrigin.toLowerCase());
+  }
+
+  async setBlacklist(
+    txOrigin: Address,
+    ttl: number = HASHFLOW_BLACKLIST_TTL_S,
+  ) {
+    await this.dexHelper.cache.setex(
+      this.dexKey,
+      this.network,
+      this.getBlackListKey(txOrigin),
+      ttl,
+      'blacklisted',
+    );
+
+    this.blacklistedPubSub.publish([txOrigin.toLowerCase()]);
+
+    return true;
+  }
+
+  async getAllBlacklisted(): Promise<Address[]> {
+    const defaultKey = this.getBlackListKey('');
+    const pattern = `${defaultKey}*`;
+    const allBlacklisted = await this.dexHelper.cache.keys(
+      this.dexKey,
+      this.network,
+      pattern,
+    );
+
+    return allBlacklisted.map(t => this.getAddressFromBlackListKey(t));
+  }
+
+  getBlackListKey(address: Address) {
+    return `blacklist_${address}`.toLowerCase();
+  }
+
+  getAddressFromBlackListKey(key: Address) {
+    return (key.split('blacklist_')[1] ?? '').toLowerCase();
+  }
 }

package/src/dex/hashflow/types.ts

@@ -64,7 +64,6 @@ export type HashflowRateFetcherConfig = {
     };
     pricesIntervalMs: number;
     markerMakersIntervalMs: number;
-    getCachedMarketMakers: () => Promise<string[] | null>;
     filterMarketMakers: (makers: string[]) => Promise<string[]>;
     pricesCacheKey: string;
     marketMakersCacheKey: string;

package/src/dex/idle-dao/idle-dao--gas-estimation.test.ts

@@ -0,0 +1,30 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('IdleDao Gas Estimation', () => {
+  const dexKey = 'IdleDao';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const STETH = Tokens[network]['STETH'];
+    const AA_wstETH = Tokens[network]['AA_wstETH'];
+    const amount = 1000000000000000000n;
+
+    // todo: uncomment? (the dex doesn't seem to be working)
+    // it('deposit', async () => {
+    //   await testGasEstimation(
+    //     network,
+    //     STETH,
+    //     AA_wstETH,
+    //     amount,
+    //     SwapSide.SELL,
+    //     dexKey,
+    //     ContractMethodV6.swapExactAmountIn,
+    //   );
+    // });
+  });
+});

package/src/dex/lido/lido-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('Lido Gas Estimation', () => {
+  const dexKey = 'Lido';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const STETH = Tokens[network]['STETH'];
+    const ETH = Tokens[network]['ETH'];
+    const amount = 100000000000000000000n;
+
+    it('submit', async () => {
+      await testGasEstimation(
+        network,
+        ETH,
+        STETH,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/lite-psm/lite-psm-gas-estimation.test.ts

@@ -0,0 +1,34 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+dotenv.config();
+
+describe('LitePsm Gas Estimation', () => {
+  const dexKey = 'LitePsm';
+  const network = Network.MAINNET;
+  const srcToken = Tokens[network]['USDC'];
+  const destToken = Tokens[network]['DAI'];
+  const methods: ContractMethodV6[] = [
+    ContractMethodV6.swapExactAmountInOutOnMakerPSM,
+    ContractMethodV6.swapExactAmountIn,
+  ];
+  const amount = 10000000n;
+
+  methods.forEach(async method => {
+    it(method, async () => {
+      await testGasEstimation(
+        network,
+        srcToken,
+        destToken,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        method,
+      );
+    });
+  });
+});

package/src/dex/maker-psm/maker-psm-gas-estimation.test.ts

@@ -0,0 +1,34 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+dotenv.config();
+
+describe('MakerPsm Gas Estimation', () => {
+  const dexKey = 'MakerPsm';
+  const network = Network.MAINNET;
+  const srcToken = Tokens[network]['USDC'];
+  const destToken = Tokens[network]['DAI'];
+  const methods: ContractMethodV6[] = [
+    ContractMethodV6.swapExactAmountInOutOnMakerPSM,
+    ContractMethodV6.swapExactAmountIn,
+  ];
+  const amount = 10000000n;
+
+  methods.forEach(async method => {
+    it(method, async () => {
+      await testGasEstimation(
+        network,
+        srcToken,
+        destToken,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        method,
+      );
+    });
+  });
+});

package/src/dex/maverick-v1/maverick-v1-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('MaverickV1 Gas Estimation', () => {
+  const dexKey = 'MaverickV1';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 1000000n;
+
+    it('exactInputSingle', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/maverick-v2/maverick-v2-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('MaverickV2 Gas Estimation', () => {
+  const dexKey = 'MaverickV2';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    it('swap', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});

package/src/dex/pancakeswap-v3/pancakeswap-v3-gas-estimation.test.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import 'dotenv/config';
+import { testGasEstimation } from '../../../tests/utils-e2e';
+import { Tokens } from '../../../tests/constants-e2e';
+import { Network, SwapSide } from '../../constants';
+import { ContractMethodV6 } from '@paraswap/core';
+
+describe('PancakeswapV3 Gas Estimation', () => {
+  const dexKey = 'PancakeswapV3';
+  const network = Network.MAINNET;
+
+  describe('swapExactAmountIn', () => {
+    const USDT = Tokens[network]['USDT'];
+    const USDC = Tokens[network]['USDC'];
+    const amount = 100000000n;
+
+    it('exactInput', async () => {
+      await testGasEstimation(
+        network,
+        USDT,
+        USDC,
+        amount,
+        SwapSide.SELL,
+        dexKey,
+        ContractMethodV6.swapExactAmountIn,
+      );
+    });
+  });
+});