refactor: refactor tools to ActionProvider pattern

package.json

@@ -2,9 +2,7 @@
   "name": "base-mcp",
   "version": "1.0.11",
   "description": "A Model Context Protocol (MCP) server that provides onchain tools for Claude AI, allowing it to interact with the Base blockchain and Coinbase API",
-  "bin": {
-    "base-mcp": "build/index.js"
-  },
+  "bin": "build/index.js",
   "type": "module",
   "scripts": {
     "run": "tsx src/index.ts",
@@ -43,7 +41,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.10.0",
-    "@coinbase/agentkit": "^0.6.0",
+    "@coinbase/agentkit": "^0.6.2",
     "@coinbase/agentkit-model-context-protocol": "^0.2.0",
     "@coinbase/coinbase-sdk": "^0.21.0",
     "@coinbase/onchainkit": "^0.37.6",

src/main.ts

@@ -27,7 +27,9 @@ import { english, generateMnemonic, mnemonicToAccount } from 'viem/accounts';
 import { base } from 'viem/chains';
 import { Event, postMetric } from './analytics.js';
 import { chainIdToCdpNetworkId, chainIdToChain } from './chains.js';
+import { baseMcpContractActionProvider } from './tools/contracts/index.js';
 import { baseMcpTools, toolToHandler } from './tools/index.js';
+import { baseMcpMorphoActionProvider } from './tools/morpho/index.js';
 import {
   generateSessionId,
   getActionProvidersWithRequiredEnvVars,
@@ -92,6 +94,10 @@ export async function main() {
         apiKeyPrivateKey: privateKey,
       }),
       ...getActionProvidersWithRequiredEnvVars(),
+
+      // Base MCP Action Providers
+      baseMcpMorphoActionProvider(),
+      baseMcpContractActionProvider(),
     ],
   });
 
@@ -118,8 +124,9 @@ export async function main() {
 
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     console.error('Received ListToolsRequest');
+
     return {
-      tools: [...baseMcpTools.map((tool) => tool.definition), ...tools],
+      tools: [...baseMcpTools, ...tools],
     };
   });
 

src/tools/contracts/index.ts

@@ -1,10 +1,101 @@
-import { generateTool } from '../../utils.js';
-import { callContractHandler } from './handlers.js';
+import {
+  ActionProvider,
+  CreateAction,
+  EvmWalletProvider,
+  type Network,
+} from '@coinbase/agentkit';
+import {
+  encodeFunctionData,
+  isAddress,
+  type Abi,
+  type AbiFunction,
+} from 'viem';
+import { base, baseSepolia } from 'viem/chains';
+import type { z } from 'zod';
+import { chainIdToChain } from '../../chains.js';
+import { constructBaseScanUrl } from '../utils/index.js';
 import { CallContractSchema } from './schemas.js';
 
-export const callContractTool = generateTool({
-  name: 'call_contract',
-  description: 'Call a contract function',
-  inputSchema: CallContractSchema,
-  toolHandler: callContractHandler,
-});
+export class BaseMcpContractActionProvider extends ActionProvider<EvmWalletProvider> {
+  constructor() {
+    super('baseMcpContract', []);
+  }
+
+  @CreateAction({
+    name: 'call_contract',
+    description: 'Call a contract function',
+    schema: CallContractSchema,
+  })
+  async callContract(
+    walletProvider: EvmWalletProvider,
+    args: z.infer<typeof CallContractSchema>,
+  ) {
+    let abi: string | Abi = args.abi;
+    try {
+      abi = JSON.parse(abi) as Abi;
+    } catch (error) {
+      throw new Error(`Invalid ABI: ${error}`);
+    }
+
+    if (!isAddress(args.contractAddress, { strict: false })) {
+      throw new Error(`Invalid contract address: ${args.contractAddress}`);
+    }
+    let functionAbi: AbiFunction | undefined;
+
+    try {
+      functionAbi = abi.find(
+        (item) => 'name' in item && item.name === args.functionName,
+      ) as AbiFunction;
+    } catch (error) {
+      throw new Error(`Invalid function name: ${args.functionName}. ${error}`);
+    }
+
+    const chain = chainIdToChain(Number(walletProvider.getNetwork().chainId));
+    if (!chain) {
+      throw new Error(
+        `Unsupported chainId: ${walletProvider.getNetwork().chainId}`,
+      );
+    }
+
+    if (
+      functionAbi.stateMutability === 'view' ||
+      functionAbi.stateMutability === 'pure'
+    ) {
+      const tx = await walletProvider.readContract({
+        address: args.contractAddress,
+        abi,
+        functionName: args.functionName,
+        args: args.functionArgs,
+      });
+
+      return String(tx);
+    }
+
+    const tx = await walletProvider.sendTransaction({
+      to: args.contractAddress,
+      data: encodeFunctionData({
+        abi,
+        functionName: args.functionName,
+        args: args.functionArgs,
+      }),
+      value: BigInt(args.value ?? 0),
+    });
+
+    const link = constructBaseScanUrl(chain, tx);
+
+    return JSON.stringify({
+      hash: tx,
+      url: link,
+    });
+  }
+
+  supportsNetwork(network: Network): boolean {
+    return (
+      network.chainId === String(base.id) ||
+      network.chainId === String(baseSepolia.id)
+    );
+  }
+}
+
+export const baseMcpContractActionProvider = () =>
+  new BaseMcpContractActionProvider();

src/tools/farcaster/handlers.ts

@@ -4,92 +4,99 @@ import { FarcasterUsernameSchema } from './schemas.js';
 
 // Neynar API response types
 type NeynarUserResponse = {
-    result: {
-        users: Array<{
-            fid: number;
-            username: string;
-            verified_addresses: {
-                eth_addresses: string[];
-                primary: {
-                    eth_address: string;
-                };
-            };
-        }>;
-    };
+  result: {
+    users: Array<{
+      fid: number;
+      username: string;
+      verified_addresses: {
+        eth_addresses: string[];
+        primary: {
+          eth_address: string;
+        };
+      };
+    }>;
+  };
 };
 
 export async function farcasterUsernameHandler(
-    wallet: WalletClient & PublicActions,
-    args: z.infer<typeof FarcasterUsernameSchema>,
+  wallet: WalletClient & PublicActions,
+  args: z.infer<typeof FarcasterUsernameSchema>,
 ): Promise<string> {
-    const { username } = args;
+  const { username } = args;
 
-    // Get Neynar API key from environment variables
-    const neynarApiKey = process.env.NEYNAR_API_KEY;
+  // Get Neynar API key from environment variables
+  const neynarApiKey = process.env.NEYNAR_API_KEY;
 
-    if (!neynarApiKey) {
-        throw new Error('NEYNAR_API_KEY environment variable is not set');
-    }
+  if (!neynarApiKey) {
+    throw new Error('NEYNAR_API_KEY environment variable is not set');
+  }
 
-    try {
-        // Call Neynar API to search for the user
-        const response = await fetch(
-            `https://api.neynar.com/v2/farcaster/user/search?q=${encodeURIComponent(username)}`,
-            {
-                headers: {
-                    'accept': 'application/json',
-                    'x-api-key': neynarApiKey,
-                },
-            }
-        );
+  try {
+    // Call Neynar API to search for the user
+    const response = await fetch(
+      `https://api.neynar.com/v2/farcaster/user/search?q=${encodeURIComponent(username)}`,
+      {
+        headers: {
+          accept: 'application/json',
+          'x-api-key': neynarApiKey,
+        },
+      },
+    );
 
-        if (!response.ok) {
-            throw new Error(`Neynar API error: ${response.status} ${response.statusText}`);
-        }
+    if (!response.ok) {
+      throw new Error(
+        `Neynar API error: ${response.status} ${response.statusText}`,
+      );
+    }
 
-        const data = (await response.json()) as NeynarUserResponse;
+    const data = (await response.json()) as NeynarUserResponse;
 
-        // Check if any users were found
-        if (!data.result.users || data.result.users.length === 0) {
-            return JSON.stringify({
-                success: false,
-                message: `No Farcaster user found with username: ${username}`,
-            });
-        }
+    // Check if any users were found
+    if (!data.result.users || data.result.users.length === 0) {
+      return JSON.stringify({
+        success: false,
+        message: `No Farcaster user found with username: ${username}`,
+      });
+    }
 
-        // Find the user with the matching username (case-insensitive)
-        const user = data.result.users.find(
-            (u) => u.username.toLowerCase() === username.toLowerCase()
-        );
+    // Find the user with the matching username (case-insensitive)
+    const user = data.result.users.find(
+      (u) => u.username.toLowerCase() === username.toLowerCase(),
+    );
 
-        if (!user) {
-            return JSON.stringify({
-                success: false,
-                message: `No Farcaster user found with username: ${username}`,
-            });
-        }
+    if (!user) {
+      return JSON.stringify({
+        success: false,
+        message: `No Farcaster user found with username: ${username}`,
+      });
+    }
 
-        // Check if the user has any verified Ethereum addresses
-        if (!user.verified_addresses?.eth_addresses || user.verified_addresses.eth_addresses.length === 0) {
-            return JSON.stringify({
-                success: false,
-                message: `User ${username} has no verified Ethereum addresses`,
-            });
-        }
+    // Check if the user has any verified Ethereum addresses
+    if (
+      !user.verified_addresses?.eth_addresses ||
+      user.verified_addresses.eth_addresses.length === 0
+    ) {
+      return JSON.stringify({
+        success: false,
+        message: `User ${username} has no verified Ethereum addresses`,
+      });
+    }
 
-        // Return the primary Ethereum address if available, otherwise the first one
-        const ethAddress = user.verified_addresses.primary?.eth_address || user.verified_addresses.eth_addresses[0];
+    // Return the primary Ethereum address if available, otherwise the first one
+    const ethAddress =
+      user.verified_addresses.primary?.eth_address ||
+      user.verified_addresses.eth_addresses[0];
 
-        return JSON.stringify({
-            success: true,
-            username: user.username,
-            fid: user.fid,
-            ethAddress,
-        });
-    } catch (error) {
-        return JSON.stringify({
-            success: false,
-            message: `Error resolving Farcaster username: ${error instanceof Error ? error.message : String(error)}`,
-        });
-    }
-} 
+    return JSON.stringify({
+      success: true,
+      username: user.username,
+      fid: user.fid,
+      ethAddress,
+    });
+  } catch (error) {
+    return JSON.stringify({
+      success: false,
+      message: `Error resolving Farcaster username: ${error instanceof Error ? error.message : String(error)}`,
+    });
+  }
+}