Merge pull request #50 from VenusProtocol/filter-conversion-pairs-list-by-converter

feat: filter conversion pairs list by converter

Author: coreyar

packages/cli/source/commands/conversionPairs.tsx

@@ -1,32 +1,67 @@
+import { option } from "pastel";
+import zod from "zod";
 import { useEffect, useState } from "react";
 import { Box, Text, useApp } from "ink";
-import { TokenConverterConfigs, getAllConverterConfigs } from "@venusprotocol/keeper-bots";
+import {
+  BalanceResult,
+  getAllConverterConfigs,
+  getConverterConfigsByConverter,
+  getTokenConvertersTokenBalances,
+} from "@venusprotocol/keeper-bots";
+import { addressValidation } from "../utils/validation.js";
+
+export const options = zod.object({
+  converter: addressValidation
+    .describe(
+      option({
+        description: "Token converter address",
+        alias: "c",
+      }),
+    )
+    .optional(),
+});
+
+interface Props {
+  options: zod.infer<typeof options>;
+}
 
 /**
  * Helper command to list available conversion pairs
  */
-export default function ConversionPairs() {
-  const [configs, setConfigs] = useState<TokenConverterConfigs>([]);
+export default function ConversionPairs({ options }: Props) {
+  const { converter } = options;
+  const [configs, setConfigs] = useState<BalanceResult[]>([]);
 
   const { exit } = useApp();
 
   useEffect(() => {
     (async () => {
-      const configs = await getAllConverterConfigs();
-      setConfigs(configs);
+      let configs = [];
+      if (converter) {
+        configs = await getConverterConfigsByConverter(converter);
+      } else {
+        configs = await getAllConverterConfigs();
+      }
+      const { results } = await getTokenConvertersTokenBalances(
+        configs,
+        "0x0000000000000000000000000000000000000000",
+        false,
+      );
+
+      setConfigs(results);
     })().finally(exit);
   }, []);
 
   return (
     <Box flexDirection="column">
       {configs.map(c => (
-        <Box key={c.id} flexDirection="row">
-          <Text>Token Converter: {c.tokenConverter.id} </Text>
+        <Box key={`${c.tokenConverter}-${c.assetIn.address}-${c.assetOut.address}`} flexDirection="row">
+          <Text>Token Converter: {c.tokenConverter} </Text>
           <Text>
-            Token In: {c.tokenIn.symbol} {c.tokenIn.address}{" "}
+            Token In: {c.assetIn.symbol} {c.assetIn.address}{" "}
           </Text>
           <Text>
-            Token Out: {c.tokenOut.symbol} {c.tokenOut.address}
+            Token Out: {c.assetOut.symbol} {c.assetOut.address} (Balance {c.assetOut.balance.toString()})
           </Text>
         </Box>
       ))}

packages/cli/source/commands/convert.tsx

@@ -176,7 +176,8 @@ export default function Convert({ options }: Props) {
         await Promise.allSettled(
           potentialConversions.map(async (t: any) => {
             let amountOut = t.assetOut.balance;
-            const vTokenAddress = t.assetOutVTokens.core || t.assetOutVTokens.isolated[1];
+
+            const vTokenAddress = t.assetOutVTokens.core || t.assetOutVTokens.isolated[0][1];
             const { underlyingPriceUsd, underlyingUsdValue, underlyingDecimals } = await tokenConverter.getUsdValue(
               t.assetOut.address,
               vTokenAddress,
@@ -191,7 +192,7 @@ export default function Convert({ options }: Props) {
               const arbitrageArgs = await tokenConverter.prepareConversion(
                 t.tokenConverter,
                 t.assetOut.address,
-                t.assetIn,
+                t.assetIn.address,
                 amountOut,
               );
 
@@ -209,7 +210,7 @@ export default function Convert({ options }: Props) {
                   context: {
                     converter: t.tokenConverter,
                     tokenToReceiveFromConverter: t.assetOut.address,
-                    tokenToSendToConverter: t.assetIn,
+                    tokenToSendToConverter: t.assetIn.address,
                     amount,
                     minIncome,
                     percentage: Number((minIncome * 10000000n) / amount) / 10000000,
@@ -225,7 +226,7 @@ export default function Convert({ options }: Props) {
                   context: {
                     converter: t.tokenConverter.id,
                     tokenToReceiveFromConverter: t.assetOut.address,
-                    tokenToSendToConverter: t.assetIn,
+                    tokenToSendToConverter: t.assetIn.address,
                     amount,
                     minIncome,
                     percentage: Number((minIncome * 10000000n) / amount) / 10000000,
@@ -239,7 +240,7 @@ export default function Convert({ options }: Props) {
                   context: {
                     converter: t.tokenConverter.id,
                     tokenToReceiveFromConverter: t.assetOut.address,
-                    tokenToSendToConverter: t.assetIn,
+                    tokenToSendToConverter: t.assetIn.address,
                     amount,
                     minIncome,
                     percentage: Number((minIncome * 10000000n) / amount) / 10000000,

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

@@ -530,15 +530,15 @@ describe("Token Converter", () => {
       const balanceResults: BalanceResult[] = [
         {
           tokenConverter: addresses.USDCPrimeConverter,
-          assetIn: addresses.USDC,
-          assetOut: { address: addresses.BUSD, balance: 600000000000000000000n },
+          assetIn: { address: addresses.USDC, symbol: "USDC", decimals: 18 },
+          assetOut: { address: addresses.BUSD, balance: 600000000000000000000n, symbol: "BUSD", decimals: 18 },
           assetOutVTokens: { core: addresses.vBNBCore, isolated: [] },
           accountBalanceAssetOut: 6000000000000000000n,
         },
         {
           tokenConverter: addresses.USDTPrimeConverter,
-          assetIn: addresses.USDT,
-          assetOut: { address: addresses.WBNB, balance: 400000000000000000000n },
+          assetIn: { address: addresses.USDT, symbol: "USDT", decimals: 18 },
+          assetOut: { address: addresses.WBNB, balance: 400000000000000000000n, symbol: "BUSD", decimals: 18 },
           assetOutVTokens: { core: undefined, isolated: [[addresses.stableCoinComptroller, addresses.vBNBIL]] },
           accountBalanceAssetOut: 4000000000000000000n,
         },

packages/keeper-bots/src/converter-bot/queries/getTokenConvertersTokenBalances.ts

@@ -13,8 +13,12 @@ import getVTokensFromUnderlying from "./getVTokensFromUnderlying";
 
 export interface BalanceResult {
   tokenConverter: Address;
-  assetIn: Address;
-  assetOut: { address: Address; balance: bigint };
+  assetIn: {
+    address: Address;
+    symbol?: string | null;
+    decimals: number;
+  };
+  assetOut: { address: Address; balance: bigint; symbol?: string | null; decimals: number };
   assetOutVTokens: {
     core: `0x${string}` | undefined;
     isolated: [`0x${string}`, `0x${string}`][] | undefined;
@@ -32,20 +36,20 @@ const formatResults = async (
   for (let i = 0; i < results.length; i += chunkSize) {
     const index = (i + chunkSize) / chunkSize - 1;
     const tokenConverter = tokenConverterConfigs[index].tokenConverter.id as Address;
-    const assetIn = tokenConverterConfigs[index].tokenIn.address;
-    const assetOut = tokenConverterConfigs[index].tokenOut.address;
+    const assetIn = tokenConverterConfigs[index].tokenIn;
+    const assetOut = tokenConverterConfigs[index].tokenOut;
 
     const curr = results.slice(i, i + chunkSize);
 
-    const { coreVTokens, isolatedVTokens } = await getVTokensFromUnderlying(assetOut);
+    const { coreVTokens, isolatedVTokens } = await getVTokensFromUnderlying(assetOut.address);
     const balance = {
       assetOutVTokens: {
         core: coreVTokens[0]?.id as Address,
         isolated: isolatedVTokens.map(v => [v.pool.id, v.id] as [Address, Address]),
       },
       tokenConverter,
       assetIn,
-      assetOut: { address: assetOut, balance: BigInt(curr[0].toString()) },
+      assetOut: { ...assetOut, balance: BigInt(curr[0].toString()) },
       accountBalanceAssetOut: BigInt(curr[1].toString()),
     };