fix: refactor get best trade to query amount again

Author: coreyar

packages/keeper-bots/src/converter-bot/TokenConverter.test.ts

@@ -77,9 +77,14 @@ describe("Token Converter", () => {
       (SmartRouter.getBestTrade as jest.Mock).mockImplementationOnce(() => null);
 
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      expect(tokenConverter.getBestTrade(addresses.WBNB, addresses.USDC, 1000000000000000000000n)).rejects.toThrow(
-        "No trade found",
-      );
+      expect(
+        tokenConverter.getBestTrade(
+          addresses.USDCPrimeConverter,
+          addresses.WBNB,
+          addresses.USDC,
+          1000000000000000000000n,
+        ),
+      ).rejects.toThrow("No trade found");
     });
 
     test("should handle thrown error", async () => {
@@ -96,9 +101,14 @@ describe("Token Converter", () => {
         throw new Error("Cannot find a valid swap route");
       });
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      expect(tokenConverter.getBestTrade(addresses.WBNB, addresses.USDC, 1000000000000000000000n)).rejects.toThrow(
-        "Error getting best trade - Cannot find a valid swap route",
-      );
+      expect(
+        tokenConverter.getBestTrade(
+          addresses.USDCPrimeConverter,
+          addresses.WBNB,
+          addresses.USDC,
+          1000000000000000000000n,
+        ),
+      ).rejects.toThrow("Error getting best trade - Cannot find a valid swap route");
     });
 
     test("should return trade with low price impact", async () => {
@@ -110,7 +120,12 @@ describe("Token Converter", () => {
       (tokenConverter.publicClient.simulateContract as jest.Mock).mockImplementation(() => ({
         result: [1000000000000000000n, 1000000000000000000n],
       }));
-      const trade = await tokenConverter.getBestTrade(addresses.WBNB, addresses.USDC, 1000000000000000000000n);
+      const [trade] = await tokenConverter.getBestTrade(
+        addresses.USDCPrimeConverter,
+        addresses.WBNB,
+        addresses.USDC,
+        1000000000000000000000n,
+      );
 
       expect(trade.inputToken).toEqual({
         address: "0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c",
@@ -176,7 +191,12 @@ describe("Token Converter", () => {
         return new Percent(9n, 1000n);
       });
 
-      const trade = await pancakeSwapProvider.getBestTrade(addresses.WBNB, addresses.USDC, 1000000000000000000000n);
+      const [trade] = await pancakeSwapProvider.getBestTrade(
+        addresses.USDCPrimeConverter,
+        addresses.WBNB,
+        addresses.USDC,
+        1000000000000000000000n,
+      );
 
       expect(trade.inputToken).toEqual({
         address: "0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c",

packages/keeper-bots/src/converter-bot/TokenConverter.ts

@@ -50,8 +50,13 @@ export class TokenConverter extends BotBase {
    * @param amount The amount we will receive from the converter of swapFrom
    * @returns [SmartRouterTrade, [amount transferred out of converter, amount transferred in]]
    */
-  async getBestTrade(swapFrom: Address, swapTo: Address, amount: bigint): Promise<TradeRoute> {
-    return this.swapProvider.getBestTrade(swapFrom, swapTo, amount);
+  async getBestTrade(
+    tokenConverter: Address,
+    swapFrom: Address,
+    swapTo: Address,
+    amount: bigint,
+  ): Promise<[TradeRoute, bigint]> {
+    return this.swapProvider.getBestTrade(tokenConverter, swapFrom, swapTo, amount);
   }
 
   /**
@@ -384,7 +389,7 @@ export class TokenConverter extends BotBase {
   async prepareConversion(tokenConverter: Address, assetOut: Address, assetIn: Address, amountOut: bigint) {
     let error;
     let trade;
-    let tradeAmount;
+    let amount;
 
     // [amount transferred out of converter, amount transferred in]
     const { result: updatedAmountIn } = await this.publicClient.simulateContract({
@@ -395,14 +400,13 @@ export class TokenConverter extends BotBase {
     });
 
     try {
-      trade = await this.getBestTrade(assetOut, assetIn, updatedAmountIn[1]);
+      [trade, amount] = await this.getBestTrade(tokenConverter, assetOut, assetIn, updatedAmountIn[0]);
     } catch (e) {
       error = (e as Error).message;
     } finally {
-      let tradeContext: Pick<GetBestTradeMessage["context"], "tradeAmount" | "swap"> = {};
-      if (trade && tradeAmount) {
+      let tradeContext: Pick<GetBestTradeMessage["context"], "swap"> = {};
+      if (trade) {
         tradeContext = {
-          tradeAmount: { amountOut: tradeAmount && tradeAmount[0], amountIn: tradeAmount && tradeAmount[1] },
           swap: {
             inputToken: {
               amount: trade.inputToken.amount.toFixed(0),
@@ -428,13 +432,13 @@ export class TokenConverter extends BotBase {
       });
     }
 
-    if (trade && tradeAmount) {
+    if (trade && amount) {
       // the difference between the token you get from TokenConverter and the token you pay to the MM
-      const minIncome = new Fraction(tradeAmount[0], 1).subtract(trade.inputToken.amount);
+      const minIncome = new Fraction(amount).subtract(trade.inputToken.amount);
       return {
         trade,
-        amount: tradeAmount[0],
-        minIncome: BigInt(minIncome.toFixed(0, { groupSeparator: "" })),
+        amount: trade.inputToken.amount.quotient,
+        minIncome: minIncome.quotient,
       };
     }
   }

packages/keeper-bots/src/providers/pancake-swap.ts

@@ -5,6 +5,7 @@ import { Address, Hex, encodePacked, erc20Abi } from "viem";
 
 import getConfig from "../config";
 import type { SUPPORTED_CHAINS } from "../config/chains";
+import { tokenConverterAbi } from "../config/abis/generated";
 import { chains } from "../config/chains";
 import { ConverterBotMessage } from "../converter-bot/types";
 import { TradeRoute } from "../types";
@@ -22,9 +23,9 @@ class PancakeSwapProvider extends SwapProvider {
     super({ subscriber });
     this.v3PancakeSubgraphClient = config.swapSubgraphUrl
       ? createClient({
-          url: config.swapSubgraphUrl,
-          requestPolicy: "network-only",
-        })
+        url: config.swapSubgraphUrl,
+        requestPolicy: "network-only",
+      })
       : undefined;
 
     this.quoteProvider = SmartRouter.createQuoteProvider({ onChainProvider: () => this.publicClient });
@@ -66,10 +67,18 @@ class PancakeSwapProvider extends SwapProvider {
     throw new Error(`Unable to fetch token details for ${address}`);
   }
 
-  async getBestTrade(swapFrom: Address, swapTo: Address, amount: bigint): Promise<TradeRoute> {
+  async getBestTrade(tokenConverter: Address, swapFrom: Address, swapTo: Address, amount: bigint): Promise<[TradeRoute, bigint]> {
     const swapFromToken = await this.getToken(swapFrom);
     const swapToToken = await this.getToken(swapTo);
 
+    // [amount transferred out of converter, amount transferred in]
+    const { result: updatedAmountIn } = await this.publicClient.simulateContract({
+      address: tokenConverter,
+      abi: tokenConverterAbi,
+      functionName: "getUpdatedAmountIn",
+      args: [amount, swapTo, swapFrom],
+    });
+
     const candidatePools = await SmartRouter.getV3CandidatePools({
       onChainProvider: () => this.publicClient,
       subgraphProvider: () => this.v3PancakeSubgraphClient,
@@ -82,7 +91,7 @@ class PancakeSwapProvider extends SwapProvider {
 
     try {
       const response = await SmartRouter.getBestTrade(
-        CurrencyAmount.fromRawAmount(swapToToken, amount),
+        CurrencyAmount.fromRawAmount(swapToToken, updatedAmountIn[1]),
         swapFromToken,
         TradeType.EXACT_OUTPUT,
         {
@@ -94,6 +103,7 @@ class PancakeSwapProvider extends SwapProvider {
           quoterOptimization: true,
         },
       );
+
       if (response) {
         trade = {
           inputToken: {
@@ -128,9 +138,9 @@ class PancakeSwapProvider extends SwapProvider {
         },
       });
 
-      return this.getBestTrade(swapFrom, swapTo, (amount * 75n) / 100n);
+      return this.getBestTrade(tokenConverter, swapFrom, swapTo, (updatedAmountIn[1] * 75n) / 100n);
     }
-    return trade;
+    return [trade, amount];
   }
 
   /**

packages/keeper-bots/src/providers/swap-provider.ts

@@ -46,14 +46,14 @@ class SwapProvider {
 
   async getBestTrade(
     // eslint-disable-next-line
-    // tokenConverter: Address,
+    tokenConverter: Address,
     // eslint-disable-next-line
     swapFrom: Address,
     // eslint-disable-next-line
     swapTo: Address,
     // eslint-disable-next-line
     amount: bigint,
-  ): Promise<TradeRoute> {
+  ): Promise<[TradeRoute, bigint]> {
     throw new Error("Not Implemented Error");
   }
 }

packages/keeper-bots/src/providers/uniswap.ts

@@ -10,6 +10,7 @@ import { Address, Hex, encodePacked, erc20Abi } from "viem";
 import getConfig from "../config";
 import type { SUPPORTED_CHAINS } from "../config/chains";
 import { chains } from "../config/chains";
+import { tokenConverterAbi } from "../config/abis/generated";
 import { ConverterBotMessage } from "../converter-bot/types";
 import { TradeRoute } from "../types";
 import SwapProvider from "./swap-provider";
@@ -61,14 +62,22 @@ class UniswapProvider extends SwapProvider {
   }
 
   async getBestTrade(
-    // tokenConverter: Address,
+    tokenConverter: Address,
     swapFrom: Address,
     swapTo: Address,
     amount: bigint,
-  ): Promise<TradeRoute> {
+  ): Promise<[TradeRoute, bigint]> {
     const swapFromToken = await this.getToken(swapFrom);
     const swapToToken = await this.getToken(swapTo);
 
+    // [amount transferred out of converter, amount transferred in]
+    const { result: updatedAmountIn } = await this.publicClient.simulateContract({
+      address: tokenConverter,
+      abi: tokenConverterAbi,
+      functionName: "getUpdatedAmountIn",
+      args: [amount, swapTo, swapFrom],
+    });
+
     const provider = new ethers.providers.JsonRpcProvider(config.rpcUrl);
     const router = new AlphaRouter({
       chainId: config.network.id as ChainId,
@@ -125,7 +134,7 @@ class UniswapProvider extends SwapProvider {
       throw new Error("No trade found");
     }
 
-    return trade;
+    return [trade, amount];
   }
 
   /**