fix: multiple issues with swap, transfer, bridge

Author: 0xbbjoker

src/actions/bridge.ts

@@ -5,21 +5,22 @@ import {
   type Memory,
   ModelType,
   type State,
-  composePrompt,
-} from "@elizaos/core";
-import { type ByteArray, type Hex, formatEther, parseEther } from "viem";
+  parseKeyValueXml,
+  composePromptFromState,
+} from '@elizaos/core';
+import { type Hex, formatEther, parseEther } from 'viem';
 
-import { type WalletProvider, initWalletProvider } from "../providers/wallet";
-import { transferTemplate } from "../templates";
-import type { Transaction, TransferParams } from "../types";
+import { type WalletProvider, initWalletProvider } from '../providers/wallet';
+import { transferTemplate } from '../templates';
+import type { Transaction, TransferParams } from '../types';
 
 // Exported for tests
 export class TransferAction {
   constructor(private walletProvider: WalletProvider) {}
 
   async transfer(params: TransferParams): Promise<Transaction> {
     if (!params.data) {
-      params.data = "0x";
+      params.data = '0x';
     }
 
     const walletClient = this.walletProvider.getWalletClient(params.fromChain);
@@ -34,12 +35,12 @@ export class TransferAction {
         to: params.toAddress,
         value: parseEther(params.amount),
         data: params.data as Hex,
-        chain: undefined,
-      } as any);
+        chain: walletClient.chain,
+      });
 
       return {
         hash,
-        from: walletClient.account?.address as `0x${string}`,
+        from: walletClient.account.address,
         to: params.toAddress,
         value: parseEther(params.amount),
         data: params.data as Hex,
@@ -53,11 +54,11 @@ export class TransferAction {
 
 const buildTransferDetails = async (
   state: State,
+  _message: Memory,
   runtime: IAgentRuntime,
   wp: WalletProvider
 ): Promise<TransferParams> => {
   const chains = wp.getSupportedChains();
-  state.supportedChains = chains.map((item) => `"${item}"`).join("|");
 
   // Add balances to state for better context in template
   const balances = await wp.getWalletBalances();
@@ -66,34 +67,52 @@ const buildTransferDetails = async (
       const chainConfig = wp.getChainConfigs(chain as any);
       return `${chain}: ${balance} ${chainConfig.nativeCurrency.symbol}`;
     })
-    .join(", ");
+    .join(', ');
 
-  const context = composePrompt({
+  state = await runtime.composeState(_message, ['RECENT_MESSAGES'], true);
+  state.supportedChains = chains.join(' | ');
+
+  const context = composePromptFromState({
     state,
     template: transferTemplate,
   });
 
-  const transferDetails = await runtime.useModel(ModelType.OBJECT_SMALL, {
-    context,
+  const xmlResponse = await runtime.useModel(ModelType.TEXT_SMALL, {
+    prompt: context,
   });
 
-  const existingChain = wp.chains[transferDetails.fromChain];
+  const parsedXml = parseKeyValueXml(xmlResponse);
+
+  if (!parsedXml) {
+    throw new Error('Failed to parse XML response from LLM for transfer details.');
+  }
+
+  const transferDetails = parsedXml as unknown as TransferParams;
+
+  // Normalize chain name to lowercase to handle case sensitivity issues
+  const normalizedChainName = transferDetails.fromChain.toLowerCase();
+
+  // Check if the normalized chain name exists in the supported chains
+  const existingChain = wp.chains[normalizedChainName];
 
   if (!existingChain) {
     throw new Error(
-      "The chain " +
+      'The chain ' +
         transferDetails.fromChain +
-        " not configured yet. Add the chain or choose one from configured: " +
+        ' not configured yet. Add the chain or choose one from configured: ' +
         chains.toString()
     );
   }
 
+  // Update the transferDetails with the normalized chain name
+  transferDetails.fromChain = normalizedChainName as any;
+
   return transferDetails;
 };
 
 export const transferAction: Action = {
-  name: "EVM_TRANSFER_TOKENS",
-  description: "Transfer tokens between addresses on the same chain",
+  name: 'EVM_TRANSFER_TOKENS',
+  description: 'Transfer tokens between addresses on the same chain',
   handler: async (
     runtime: IAgentRuntime,
     message: Memory,
@@ -109,11 +128,7 @@ export const transferAction: Action = {
     const action = new TransferAction(walletProvider);
 
     // Compose transfer context
-    const paramOptions = await buildTransferDetails(
-      state,
-      runtime,
-      walletProvider
-    );
+    const paramOptions = await buildTransferDetails(state, message, runtime, walletProvider);
 
     try {
       const transferResp = await action.transfer(paramOptions);
@@ -143,31 +158,26 @@ export const transferAction: Action = {
     }
   },
   validate: async (runtime: IAgentRuntime) => {
-    const privateKey = runtime.getSetting("EVM_PRIVATE_KEY");
-    return typeof privateKey === "string" && privateKey.startsWith("0x");
+    const privateKey = runtime.getSetting('EVM_PRIVATE_KEY');
+    return typeof privateKey === 'string' && privateKey.startsWith('0x');
   },
   examples: [
     [
       {
-        name: "assistant",
+        name: 'assistant',
         content: {
           text: "I'll help you transfer 1 ETH to 0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
-          action: "SEND_TOKENS",
+          action: 'SEND_TOKENS',
         },
       },
       {
-        name: "user",
+        name: 'user',
         content: {
-          text: "Transfer 1 ETH to 0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
-          action: "SEND_TOKENS",
+          text: 'Transfer 1 ETH to 0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+          action: 'SEND_TOKENS',
         },
       },
     ],
   ],
-  similes: [
-    "EVM_TRANSFER",
-    "EVM_SEND_TOKENS",
-    "EVM_TOKEN_TRANSFER",
-    "EVM_MOVE_TOKENS",
-  ],
+  similes: ['EVM_TRANSFER', 'EVM_SEND_TOKENS', 'EVM_TOKEN_TRANSFER', 'EVM_MOVE_TOKENS'],
 };

src/actions/swap.ts

@@ -1,11 +1,11 @@
-import { type IAgentRuntime, Service, elizaLogger } from "@elizaos/core";
+import { type IAgentRuntime, Service, logger } from '@elizaos/core';
 import {
   CACHE_REFRESH_INTERVAL_MS,
   EVM_SERVICE_NAME,
   EVM_WALLET_DATA_CACHE_KEY,
-} from "./constants";
-import { type WalletProvider, initWalletProvider } from "./providers/wallet";
-import type { SupportedChain } from "./types";
+} from './constants';
+import { type WalletProvider, initWalletProvider } from './providers/wallet';
+import type { SupportedChain } from './types';
 
 export interface EVMWalletData {
   address: string;
@@ -21,7 +21,7 @@ export interface EVMWalletData {
 
 export class EVMService extends Service {
   static serviceType: string = EVM_SERVICE_NAME;
-  capabilityDescription = "EVM blockchain wallet access";
+  capabilityDescription = 'EVM blockchain wallet access';
 
   private walletProvider: WalletProvider | null = null;
   private refreshInterval: NodeJS.Timeout | null = null;
@@ -32,7 +32,7 @@ export class EVMService extends Service {
   }
 
   static async start(runtime: IAgentRuntime): Promise<EVMService> {
-    elizaLogger.log("Initializing EVMService");
+    logger.log('Initializing EVMService');
 
     const evmService = new EVMService(runtime);
 
@@ -52,14 +52,14 @@ export class EVMService extends Service {
       CACHE_REFRESH_INTERVAL_MS
     );
 
-    elizaLogger.log("EVM service initialized");
+    logger.log('EVM service initialized');
     return evmService;
   }
 
   static async stop(runtime: IAgentRuntime) {
     const service = runtime.getService(EVM_SERVICE_NAME);
     if (!service) {
-      elizaLogger.error("EVMService not found");
+      logger.error('EVMService not found');
       return;
     }
     await service.stop();
@@ -70,7 +70,7 @@ export class EVMService extends Service {
       clearInterval(this.refreshInterval);
       this.refreshInterval = null;
     }
-    elizaLogger.log("EVM service shutdown");
+    logger.log('EVM service shutdown');
   }
 
   async refreshWalletData(): Promise<void> {
@@ -86,9 +86,7 @@ export class EVMService extends Service {
       const chainDetails = Object.entries(balances)
         .map(([chainName, balance]) => {
           try {
-            const chain = this.walletProvider!.getChainConfigs(
-              chainName as SupportedChain
-            );
+            const chain = this.walletProvider!.getChainConfigs(chainName as SupportedChain);
             return {
               chainName,
               balance,
@@ -97,52 +95,47 @@ export class EVMService extends Service {
               name: chain.name,
             };
           } catch (error) {
-            elizaLogger.error(`Error formatting chain ${chainName}:`, error);
+            logger.error(`Error formatting chain ${chainName}:`, error);
             return null;
           }
         })
         .filter(Boolean);
 
       const walletData: EVMWalletData = {
         address,
-        chains: chainDetails as EVMWalletData["chains"],
+        chains: chainDetails as EVMWalletData['chains'],
         timestamp: Date.now(),
       };
 
       // Cache the wallet data
       await this.runtime.setCache(EVM_WALLET_DATA_CACHE_KEY, walletData);
       this.lastRefreshTimestamp = walletData.timestamp;
 
-      elizaLogger.log(
-        "EVM wallet data refreshed for chains:",
-        chainDetails.map((c) => c?.chainName).join(", ")
+      logger.log(
+        'EVM wallet data refreshed for chains:',
+        chainDetails.map((c) => c?.chainName).join(', ')
       );
     } catch (error) {
-      elizaLogger.error("Error refreshing EVM wallet data:", error);
+      logger.error('Error refreshing EVM wallet data:', error);
     }
   }
 
   async getCachedData(): Promise<EVMWalletData | undefined> {
     try {
-      const cachedData = await this.runtime.getCache<EVMWalletData>(
-        EVM_WALLET_DATA_CACHE_KEY
-      );
+      const cachedData = await this.runtime.getCache<EVMWalletData>(EVM_WALLET_DATA_CACHE_KEY);
 
       const now = Date.now();
       // If data is stale or doesn't exist, refresh it
-      if (
-        !cachedData ||
-        now - cachedData.timestamp > CACHE_REFRESH_INTERVAL_MS
-      ) {
-        elizaLogger.log("EVM wallet data is stale, refreshing...");
+      if (!cachedData || now - cachedData.timestamp > CACHE_REFRESH_INTERVAL_MS) {
+        logger.log('EVM wallet data is stale, refreshing...');
         await this.refreshWalletData();
         const refreshedData = await this.runtime.getCache<EVMWalletData>(EVM_WALLET_DATA_CACHE_KEY);
-        return refreshedData || null;
+        return refreshedData || undefined;
       }
 
       return cachedData;
     } catch (error) {
-      elizaLogger.error("Error getting cached EVM wallet data:", error);
+      logger.error('Error getting cached EVM wallet data:', error);
       return undefined;
     }
   }