update price tool

Author: fishonamos

packages/sui-agent/src/protocols/aftermath/PoolTool.ts

@@ -311,6 +311,19 @@ class PoolTool {
       await sdk.init();
       const pool = await sdk.Pools().getPool({ objectId: poolId });
 
+      // Verify pool exists and has the required coins
+      if (!pool?.pool?.coins) {
+        throw new Error('Pool not found or invalid');
+      }
+
+      // Check if pool has both coins
+      const coins = Object.keys(pool.pool.coins);
+      if (!coins.includes(coinInType) || !coins.includes(coinOutType)) {
+        throw new Error(
+          `Pool does not support trading between ${coinInType} and ${coinOutType}`,
+        );
+      }
+
       const tx = await pool.getTradeTransaction({
         walletAddress,
         coinInType,
@@ -323,7 +336,15 @@ class PoolTool {
       return JSON.stringify([
         {
           reasoning: 'Successfully created trade transaction',
-          response: { tx, poolId },
+          response: {
+            tx,
+            poolId,
+            coins: {
+              in: coinInType,
+              out: coinOutType,
+              amount: coinInAmount.toString(),
+            },
+          },
           status: 'success',
           query: 'Create trade transaction',
           errors: [],

packages/sui-agent/src/protocols/aftermath/PriceTool.ts

@@ -1,118 +1,84 @@
 import { Aftermath } from 'aftermath-ts-sdk';
-import { COIN_ADDRESSES, COIN_SYNONYMS } from '../../@types/interface';
 import { handleError } from '../../utils';
 
-const af = new Aftermath('MAINNET');
-const prices = af.Prices();
+class PriceTool {
+  private static sdk: Aftermath | null = null;
 
-/**
- * Normalizes a coin symbol by handling various formats and synonyms
- * @param symbol - Raw coin symbol input
- * @returns Normalized coin symbol or null if not recognized
- */
-function normalizeCoinSymbol(symbol: string): string | null {
-  const normalized = symbol
-    .trim()
-    .toUpperCase()
-    .replace(/[^A-Z_]/g, '');
-  return COIN_SYNONYMS[normalized] || null;
-}
-
-/**
- * Fetches current price for a single coin from Aftermath Finance
- * @param coin - Coin symbol or address
- * @returns Formatted price string or error message
- */
-export async function getCoinPrice(
-  ...args: (string | number | bigint | boolean)[]
-): Promise<string> {
-  const coin = args[0] as string; // Cast first argument to string
-  try {
-    // Handle direct addresses vs symbols
-    let coinType = coin;
-    if (!coin.includes('::')) {
-      const normalizedSymbol = normalizeCoinSymbol(coin);
-      if (!normalizedSymbol) {
-        throw new Error(`Unknown coin symbol: ${coin}`);
-      }
-      coinType =
-        COIN_ADDRESSES[normalizedSymbol as keyof typeof COIN_ADDRESSES];
-      if (!coinType) {
-        throw new Error(`No address mapping for coin: ${coin}`);
-      }
+  private static initSDK(): Aftermath {
+    if (!PriceTool.sdk) {
+      PriceTool.sdk = new Aftermath('MAINNET');
     }
+    return PriceTool.sdk;
+  }
 
-    const price = await prices.getCoinPrice({ coin: coinType });
+  /**
+   * Gets current price for a single coin
+   */
+  public static async getCoinPrice(coinType: string): Promise<string> {
+    try {
+      const sdk = PriceTool.initSDK();
+      await sdk.init();
 
-    return JSON.stringify([
-      {
-        reasoning:
-          'Successfully retrieved current price from Aftermath Finance',
-        response: `The current price of ${coin} is $${price}`,
-        status: 'success',
-        query: `Fetched price for ${coin}`,
-        errors: [],
-      },
-    ]);
-  } catch (error: unknown) {
-    return JSON.stringify([
-      handleError(error, {
-        reasoning: 'Failed to fetch price from Aftermath Finance',
-        query: `Attempted to fetch price for ${coin}`,
-      }),
-    ]);
+      const priceInfo = await sdk.Prices().getCoinPriceInfo({
+        coin: coinType,
+      });
+
+      return JSON.stringify([
+        {
+          reasoning: 'Successfully retrieved current price',
+          response: {
+            price: priceInfo.price,
+            priceChange24h: priceInfo.priceChange24HoursPercentage,
+            coin: coinType,
+          },
+          status: 'success',
+          query: `Get price for ${coinType}`,
+          errors: [],
+        },
+      ]);
+    } catch (error) {
+      return JSON.stringify([
+        handleError(error, {
+          reasoning: 'Failed to fetch price',
+          query: `Get price for ${coinType}`,
+        }),
+      ]);
+    }
   }
-}
 
-/**
- * Gets price information for multiple coins from Aftermath Finance
- * @param coins - Comma-separated string of coin symbols or addresses
- * @returns JSON string containing price information or error response
- * @throws Error if price fetch fails or invalid token addresses
- */
-export async function coinsToPrice(
-  ...args: (string | number | bigint | boolean)[]
-): Promise<string> {
-  const coins = args[0] as string;
-  try {
-    // Convert coin symbols to addresses
-    const coinTypes = coins.split(',').map((coin) => {
-      const trimmed = coin.trim();
-      // Handle direct addresses
-      if (trimmed.includes('::')) {
-        return trimmed;
-      }
-      // Handle symbols
-      const normalizedSymbol = normalizeCoinSymbol(trimmed);
-      if (!normalizedSymbol) {
-        throw new Error(`Unknown coin symbol: ${trimmed}`);
-      }
-      const address =
-        COIN_ADDRESSES[normalizedSymbol as keyof typeof COIN_ADDRESSES];
-      if (!address) {
-        throw new Error(`No address mapping for coin: ${trimmed}`);
-      }
-      return address;
-    });
+  /**
+   * Gets prices for multiple coins
+   */
+  public static async getCoinsPrice(coinTypes: string[]): Promise<string> {
+    try {
+      const sdk = PriceTool.initSDK();
+      await sdk.init();
+
+      const priceInfos = await sdk.Prices().getCoinsToPriceInfo({
+        coins: coinTypes,
+      });
 
-    // Fetch prices from Aftermath
-    const priceInfo = await prices.getCoinsToPrice({ coins: coinTypes });
-    return JSON.stringify([
-      {
-        reasoning:
-          'Successfully retrieved current price information from Aftermath Finance for the requested coins.',
-        response: JSON.stringify(priceInfo, null, 2),
-        status: 'success',
-        query: `Fetched prices for coins: ${coins}`,
-        errors: [],
-      },
-    ]);
-  } catch (error: unknown) {
-    return JSON.stringify([
-      handleError(error, {
-        reasoning: 'Failed to retrieve prices from Aftermath Finance',
-        query: `Attempted to fetch prices for coins: ${coins}`,
-      }),
-    ]);
+      return JSON.stringify([
+        {
+          reasoning: 'Successfully retrieved prices',
+          response: {
+            prices: priceInfos,
+            timestamp: new Date().toISOString(),
+          },
+          status: 'success',
+          query: `Get prices for ${coinTypes.join(', ')}`,
+          errors: [],
+        },
+      ]);
+    } catch (error) {
+      return JSON.stringify([
+        handleError(error, {
+          reasoning: 'Failed to fetch prices',
+          query: `Get prices for ${coinTypes.join(', ')}`,
+        }),
+      ]);
+    }
   }
 }
+
+export { PriceTool };