Merge pull request #9 from elizaos-plugins/pr-7

fix issue with import & tsconfig

Author: wtfsayo

bun.lock

@@ -22,19 +22,18 @@
     "dist"
   ],
   "dependencies": {
-    "@elizaos/core-plugin-v2": "^1.0.0-beta",
-    "@elizaos/plugin-tee": "^1.0.0-beta",
+    "@elizaos/core": "^1.0.0",
     "@lifi/data-types": "5.15.5",
-    "@lifi/sdk": "3.4.1",
-    "@lifi/types": "16.3.0"
+    "@lifi/sdk": "^3.7.3",
+    "@lifi/types": "^17.16.0",
+    "tsup": "8.3.5"
   },
   "devDependencies": {
     "@nomicfoundation/hardhat-toolbox": "^5.0.0",
     "hardhat": "^2.22.19",
     "prettier": "3.5.3",
     "ts-node": "10.9.2",
     "tslib": "2.8.1",
-    "tsup": "^8.4.0",
     "typescript": "5.8.2",
     "vitest": "^3.1.1"
   },

package.json

@@ -1,21 +1,11 @@
-import type {
-  HandlerCallback,
-  IAgentRuntime,
-  Memory,
-  State,
-} from "@elizaos/core-plugin-v2";
-import { composePrompt, ModelType } from "@elizaos/core-plugin-v2";
-import {
-  type ExtendedChain,
-  createConfig,
-  executeRoute,
-  getRoutes,
-} from "@lifi/sdk";
-
-import { parseEther } from "viem";
-import { type WalletProvider, initWalletProvider } from "../providers/wallet";
-import { bridgeTemplate } from "../templates";
-import type { BridgeParams, Transaction } from "../types";
+import type { HandlerCallback, IAgentRuntime, Memory, State } from '@elizaos/core-plugin-v2';
+import { composePrompt, ModelType } from '@elizaos/core-plugin-v2';
+import { type ExtendedChain, createConfig, executeRoute, getRoutes } from '@lifi/sdk';
+
+import { parseEther } from 'viem';
+import { type WalletProvider, initWalletProvider } from '../providers/wallet';
+import { bridgeTemplate } from '../templates';
+import type { BridgeParams, Transaction } from '../types';
 
 export { bridgeTemplate };
 
@@ -24,26 +14,26 @@ export class BridgeAction {
 
   constructor(private walletProvider: WalletProvider) {
     this.config = createConfig({
-      integrator: "eliza",
+      integrator: 'eliza',
       chains: Object.values(this.walletProvider.chains).map((config) => ({
         id: config.id,
         name: config.name,
         key: config.name.toLowerCase(),
-        chainType: "EVM",
+        chainType: 'EVM',
         nativeToken: {
           ...config.nativeCurrency,
           chainId: config.id,
-          address: "0x0000000000000000000000000000000000000000",
+          address: '0x0000000000000000000000000000000000000000',
           coinKey: config.nativeCurrency.symbol,
         },
         metamask: {
           chainId: `0x${config.id.toString(16)}`,
           chainName: config.name,
           nativeCurrency: config.nativeCurrency,
           rpcUrls: [config.rpcUrls.default.http[0]],
-          blockExplorerUrls: [config.blockExplorers?.default.url],
+          blockExplorerUrls: [config?.blockExplorers?.default?.url],
         },
-        diamondAddress: "0x0000000000000000000000000000000000000000",
+        diamondAddress: '0x0000000000000000000000000000000000000000',
         coin: config.nativeCurrency.symbol,
         mainnet: true,
       })) as ExtendedChain[],
@@ -64,13 +54,13 @@ export class BridgeAction {
       toAddress: params.toAddress || fromAddress,
     });
 
-    if (!routes.routes.length) throw new Error("No routes found");
+    if (!routes.routes.length) throw new Error('No routes found');
 
     const execution = await executeRoute(routes.routes[0], this.config as any);
     const process = execution.steps[0]?.execution?.process[0];
 
-    if (!process?.status || process.status === "FAILED") {
-      throw new Error("Transaction failed");
+    if (!process?.status || process.status === 'FAILED') {
+      throw new Error('Transaction failed');
     }
 
     return {
@@ -89,7 +79,7 @@ const buildBridgeDetails = async (
   wp: WalletProvider
 ): Promise<BridgeParams> => {
   const chains = wp.getSupportedChains();
-  state.supportedChains = chains.map((item) => `"${item}"`).join("|");
+  state.supportedChains = chains.map((item) => `"${item}"`).join('|');
 
   // Add balances to state for better context in template
   const balances = await wp.getWalletBalances();
@@ -98,7 +88,7 @@ const buildBridgeDetails = async (
       const chainConfig = wp.getChainConfigs(chain as any);
       return `${chain}: ${balance} ${chainConfig.nativeCurrency.symbol}`;
     })
-    .join(", ");
+    .join(', ');
 
   // Compose bridge context
   const bridgeContext = composePrompt({
@@ -116,13 +106,13 @@ const buildBridgeDetails = async (
 
   if (!wp.chains[fromChain]) {
     throw new Error(
-      `Source chain ${fromChain} not configured. Available chains: ${chains.join(", ")}`
+      `Source chain ${fromChain} not configured. Available chains: ${chains.join(', ')}`
     );
   }
 
   if (!wp.chains[toChain]) {
     throw new Error(
-      `Destination chain ${toChain} not configured. Available chains: ${chains.join(", ")}`
+      `Destination chain ${toChain} not configured. Available chains: ${chains.join(', ')}`
     );
   }
 
@@ -139,25 +129,25 @@ const buildBridgeDetails = async (
 };
 
 export const bridgeAction = {
-  name: "EVM_BRIDGE_TOKENS",
-  description: "Bridge tokens between different chains",
+  name: 'EVM_BRIDGE_TOKENS',
+  description: 'Bridge tokens between different chains',
   handler: async (
     runtime: IAgentRuntime,
     _message: Memory,
-    state: State,
-    _options: Record<string, unknown>,
+    state?: State,
+    _options?: Record<string, unknown>,
     callback?: HandlerCallback
   ) => {
     const walletProvider = await initWalletProvider(runtime);
     const action = new BridgeAction(walletProvider);
 
+    if (!state) {
+      state = await runtime.composeState(_message);
+    }
+
     try {
       // Get bridge parameters
-      const bridgeOptions = await buildBridgeDetails(
-        state,
-        runtime,
-        walletProvider
-      );
+      const bridgeOptions = await buildBridgeDetails(state, runtime, walletProvider);
 
       const bridgeResp = await action.bridge(bridgeOptions);
       if (callback) {
@@ -173,33 +163,36 @@ export const bridgeAction = {
         });
       }
       return true;
-    } catch (error: unknown) {
-      const errMsg = error instanceof Error ? error.message : String(error);
-      console.error("Error in bridge handler:", errMsg);
+    } catch (error) {
+      console.error(
+        'Error in bridge handler:',
+        error instanceof Error ? error.message : 'Unknown error'
+      );
       if (callback) {
         callback({
-          text: `Error: ${errMsg}`,
-          content: { error: errMsg },
+          text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          content: { error: error instanceof Error ? error.message : 'Unknown error' },
         });
       }
       return false;
     }
   },
   template: bridgeTemplate,
   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: [
     [
       {
-        user: "user",
+        name: 'user',
+        user: 'user',
         content: {
-          text: "Bridge 1 ETH from Ethereum to Base",
-          action: "CROSS_CHAIN_TRANSFER",
+          text: 'Bridge 1 ETH from Ethereum to Base',
+          action: 'CROSS_CHAIN_TRANSFER',
         },
       },
     ],
   ],
-  similes: ["CROSS_CHAIN_TRANSFER", "CHAIN_BRIDGE", "MOVE_CROSS_CHAIN"],
+  similes: ['CROSS_CHAIN_TRANSFER', 'CHAIN_BRIDGE', 'MOVE_CROSS_CHAIN'],
 };

src/actions/bridge.ts

@@ -31,6 +31,10 @@ export class ExecuteAction {
   async execute(params: ExecuteProposalParams): Promise<Transaction> {
     const walletClient = this.walletProvider.getWalletClient(params.chain);
 
+    if (!walletClient.account) {
+      throw new Error('Wallet account is not available');
+    }
+
     const descriptionHash = keccak256(stringToHex(params.description));
 
     const txData = encodeFunctionData({
@@ -51,18 +55,7 @@ export class ExecuteAction {
         value: BigInt(0),
         data: txData as Hex,
         chain: chainConfig,
-        kzg: {
-          blobToKzgCommitment: (_blob: ByteArray): ByteArray => {
-            throw new Error("Function not implemented.");
-          },
-          computeBlobKzgProof: (
-            _blob: ByteArray,
-            _commitment: ByteArray
-          ): ByteArray => {
-            throw new Error("Function not implemented.");
-          },
-        },
-      } as any);
+      });
 
       const receipt = await publicClient.waitForTransactionReceipt({
         hash,
@@ -78,9 +71,8 @@ export class ExecuteAction {
         logs: receipt.logs,
       };
     } catch (error: unknown) {
-      throw new Error(
-        `Vote failed: ${error instanceof Error ? error.message : String(error)}`
-      );
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Vote failed: ${errorMessage}`);
     }
   }
 }
@@ -124,14 +116,11 @@ export const executeAction = {
       const walletProvider = new WalletProvider(privateKey, runtime);
       const action = new ExecuteAction(walletProvider);
       return await action.execute(executeParams);
-    } catch (error) {
-      const errMsg = error instanceof Error ? error.message : String(error);
-      console.error("Error in execute handler:", errMsg);
+    } catch (error: unknown) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error('Error in execute handler:', errorMessage);
       if (callback) {
-        callback({
-          text: `Error: ${errMsg}`,
-          content: { error: errMsg },
-        });
+        callback({ text: `Error: ${errorMessage}` });
       }
       return false;
     }

src/actions/gov-execute.ts

@@ -29,6 +29,10 @@ export class ProposeAction {
   async propose(params: ProposeProposalParams): Promise<Transaction> {
     const walletClient = this.walletProvider.getWalletClient(params.chain);
 
+    if (!walletClient.account) {
+      throw new Error('Wallet account is not available');
+    }
+
     const txData = encodeFunctionData({
       abi: governorArtifacts.abi,
       functionName: "propose",
@@ -52,18 +56,7 @@ export class ProposeAction {
         value: BigInt(0),
         data: txData as Hex,
         chain: chainConfig,
-        kzg: {
-          blobToKzgCommitment: (_blob: ByteArray): ByteArray => {
-            throw new Error("Function not implemented.");
-          },
-          computeBlobKzgProof: (
-            _blob: ByteArray,
-            _commitment: ByteArray
-          ): ByteArray => {
-            throw new Error("Function not implemented.");
-          },
-        },
-      } as any);
+      });
 
       const receipt = await publicClient.waitForTransactionReceipt({
         hash,
@@ -79,9 +72,8 @@ export class ProposeAction {
         logs: receipt.logs,
       };
     } catch (error: unknown) {
-      throw new Error(
-        `Vote failed: ${error instanceof Error ? error.message : String(error)}`
-      );
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Vote failed: ${errorMessage}`);
     }
   }
 }
@@ -124,14 +116,10 @@ export const proposeAction = {
       const action = new ProposeAction(walletProvider);
       return await action.propose(proposeParams);
     } catch (error: unknown) {
-      console.error(
-        "Error in propose handler:",
-        error instanceof Error ? error.message : String(error)
-      );
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error('Error in propose handler:', errorMessage);
       if (callback) {
-        callback({
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-        });
+        callback({ text: `Error: ${errorMessage}` });
       }
       return false;
     }