MCP Ethers Wallet

Implementation Reference

• src/tools/erc721.ts:399-418 (handler)

  The inline handler function for the approveNFT MCP tool. It invokes the approve helper from the ERC721 service, sends the transaction, and returns success/error messages with transaction hash.

      async ({ contractAddress, tokenId, approved, provider, chainId, gasOptions }) => {
        try {
          const tx = await approve(ethersService, contractAddress, approved, tokenId.toString(), provider, chainId, gasOptions);
          return {
            content: [{ 
              type: "text", 
              text: `Successfully approved ${approved} to transfer NFT #${tokenId}
  Transaction Hash: ${tx.hash}
  Waiting for confirmation...`
            }]
          };
        } catch (error) {
          return {
            isError: true,
            content: [{ 
              type: "text", 
              text: `Error approving NFT transfer: ${error instanceof Error ? error.message : String(error)}`
            }]
          };
        }

• src/tools/erc721.ts:391-397 (schema)

  Zod input schema for the approveNFT tool parameters, validating contract address, token ID, approved address, provider, chain ID, and gas options.

  {
    contractAddress: contractAddressSchema,
    tokenId: tokenIdSchema,
    approved: addressSchema,
    provider: providerSchema,
    chainId: chainIdSchema,
    gasOptions: gasOptionsSchema

• src/tools/erc721.ts:389-419 (registration)

  MCP server.tool registration for the approveNFT tool within the registerERC721Tools function. Includes name, schema, description (implicit), and handler.

    server.tool(
      "approveNFT",
      {
        contractAddress: contractAddressSchema,
        tokenId: tokenIdSchema,
        approved: addressSchema,
        provider: providerSchema,
        chainId: chainIdSchema,
        gasOptions: gasOptionsSchema
      },
      async ({ contractAddress, tokenId, approved, provider, chainId, gasOptions }) => {
        try {
          const tx = await approve(ethersService, contractAddress, approved, tokenId.toString(), provider, chainId, gasOptions);
          return {
            content: [{ 
              type: "text", 
              text: `Successfully approved ${approved} to transfer NFT #${tokenId}
  Transaction Hash: ${tx.hash}
  Waiting for confirmation...`
            }]
          };
        } catch (error) {
          return {
            isError: true,
            content: [{ 
              type: "text", 
              text: `Error approving NFT transfer: ${error instanceof Error ? error.message : String(error)}`
            }]
          };
        }
      }

• src/services/erc/erc721.ts:631-682 (helper)

  Supporting helper function that performs the actual approve transaction. Includes ownership/approval checks, contract instantiation, transaction overrides, and ethers.Contract.approve call.

  export async function approve(
    ethersService: EthersService,
    contractAddress: string,
    approvedAddress: string,
    tokenId: string | number,
    provider?: string,
    chainId?: number,
    options: TokenOperationOptions = {}
  ): Promise<ethers.TransactionResponse> {
    metrics.incrementCounter('erc721.approve');
    
    return timeAsync('erc721.approve', async () => {
      try {
        // Get provider and signer from ethers service
        const signer = ethersService['getSigner'](provider, chainId);
        const signerAddress = await signer.getAddress();
        
        // Check ownership
        const owner = await ownerOf(ethersService, contractAddress, tokenId, provider, chainId);
        
        if (owner.toLowerCase() !== signerAddress.toLowerCase()) {
          // Check if signer is approved for all
          const isApproved = await isApprovedForAll(ethersService, contractAddress, owner, signerAddress, provider, chainId);
          
          if (!isApproved) {
            throw new UnauthorizedTokenActionError(
              `Not authorized to approve token #${tokenId}. You are not the owner or approved operator.`
            );
          }
        }
        
        // Create contract instance with signer
        const contractWithSigner = new ethers.Contract(contractAddress, ERC721_ABI, signer);
        
        // Prepare transaction overrides
        const overrides: ethers.Overrides = {};
        if (options.gasLimit) overrides.gasLimit = options.gasLimit;
        if (options.gasPrice) overrides.gasPrice = options.gasPrice;
        if (options.maxFeePerGas) overrides.maxFeePerGas = options.maxFeePerGas;
        if (options.maxPriorityFeePerGas) overrides.maxPriorityFeePerGas = options.maxPriorityFeePerGas;
        if (options.nonce !== undefined) overrides.nonce = options.nonce;
        
        // Send transaction
        const tx = await contractWithSigner.approve(approvedAddress, tokenId, overrides);
        
        return tx;
      } catch (error) {
        logger.debug('Error approving address for NFT', { contractAddress, tokenId, approvedAddress, error });
        throw handleTokenError(error, 'Failed to approve address for NFT');
      }
    });
  }

• src/tools/index.ts:12-25 (registration)

  Top-level registration in tools index: imports and calls registerERC721Tools which registers approveNFT among other ERC721 tools.

  import { registerERC721Tools } from './erc721.js';
  import { registerERC1155Tools } from './erc1155.js';
  import { registerNetworkTools } from './networkTools.js';
  import { registerPromptTools } from './promptTools.js';
  import { silentLogger } from "../utils/silentLogger.js";
  
  /**
   * Registers all tools with the MCP server
   */
  export function registerAllTools(server: McpServer, ethersService: any) {
    // Register tool categories
    registerCoreTools(server, ethersService);
    registerERC20Tools(server, ethersService);
    registerERC721Tools(server, ethersService);