approve_token_spending

Instructions

Implementation Reference

• src/core/tools.ts:1086-1129 (registration)

  Registration of the 'approve_token_spending' MCP tool, including input schema, annotations, and handler function that delegates to services.approveERC20

  server.registerTool(
    "approve_token_spending",
    {
      description: "Approve a spender (contract) to spend tokens on your behalf. Required before interacting with DEXes, lending protocols, etc.",
      inputSchema: {
        tokenAddress: z.string().describe("The ERC20 token contract address"),
        spenderAddress: z.string().describe("The address that will be allowed to spend tokens (usually a contract)"),
        amount: z.string().describe("Amount to approve (in token units). Use '0' to revoke approval."),
        network: z.string().optional().describe("Network name or chain ID. Defaults to Ethereum mainnet.")
      },
      annotations: {
        title: "Approve Token Spending",
        readOnlyHint: false,
        destructiveHint: false,
        idempotentHint: false,
        openWorldHint: true
      }
    },
    async ({ tokenAddress, spenderAddress, amount, network = "ethereum" }) => {
      try {
        const privateKey = getConfiguredPrivateKey();
        const senderAddress = getWalletAddressFromKey();
        const txHash = await services.approveERC20(tokenAddress as Address, spenderAddress as Address, amount, privateKey, network);
        return {
          content: [{
            type: "text",
            text: JSON.stringify({
              network,
              tokenAddress,
              owner: senderAddress,
              spender: spenderAddress,
              approvalAmount: amount,
              txHash,
              message: "Approval transaction sent. Use get_transaction_receipt to check confirmation."
            }, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{ type: "text", text: `Error approving token spending: ${error instanceof Error ? error.message : String(error)}` }],
          isError: true
        };
      }
    }

• src/core/services/transfer.ts:235-300 (handler)

  Core implementation of ERC20 approve logic: resolves addresses, fetches token decimals/symbol, parses amount, and sends approve transaction using viem walletClient.writeContract

  export async function approveERC20(
    tokenAddressOrEns: string,
    spenderAddressOrEns: string,
    amount: string,
    privateKey: string | `0x${string}`,
    network: string = 'ethereum'
  ): Promise<{
    txHash: Hash;
    amount: {
      raw: bigint;
      formatted: string;
    };
    token: {
      symbol: string;
      decimals: number;
    };
  }> {
    // Resolve ENS names to addresses if needed
    const tokenAddress = await resolveAddress(tokenAddressOrEns, network) as Address;
    const spenderAddress = await resolveAddress(spenderAddressOrEns, network) as Address;
    
    // Ensure the private key has 0x prefix
    const formattedKey = typeof privateKey === 'string' && !privateKey.startsWith('0x')
      ? `0x${privateKey}` as `0x${string}`
      : privateKey as `0x${string}`;
    
    // Get token details
    const publicClient = getPublicClient(network);
    const contract = getContract({
      address: tokenAddress,
      abi: erc20TransferAbi,
      client: publicClient,
    });
    
    // Get token decimals and symbol
    const decimals = await contract.read.decimals();
    const symbol = await contract.read.symbol();
    
    // Parse the amount with the correct number of decimals
    const rawAmount = parseUnits(amount, decimals);
    
    // Create wallet client for sending the transaction
    const walletClient = getWalletClient(formattedKey, network);
    
    // Send the transaction
    const hash = await walletClient.writeContract({
      address: tokenAddress,
      abi: erc20TransferAbi,
      functionName: 'approve',
      args: [spenderAddress, rawAmount],
      account: walletClient.account!,
      chain: walletClient.chain
    });
    
    return {
      txHash: hash,
      amount: {
        raw: rawAmount,
        formatted: amount
      },
      token: {
        symbol,
        decimals
      }
    };
  }

• src/core/tools.ts:1091-1095 (schema)

  Zod input schema for the approve_token_spending tool parameters

    tokenAddress: z.string().describe("The ERC20 token contract address"),
    spenderAddress: z.string().describe("The address that will be allowed to spend tokens (usually a contract)"),
    amount: z.string().describe("Amount to approve (in token units). Use '0' to revoke approval."),
    network: z.string().optional().describe("Network name or chain ID. Defaults to Ethereum mainnet.")
  },

• src/core/services/transfer.ts:17-52 (helper)

  ERC20 ABI snippet used for approve, decimals, and symbol reads/writes in the approveERC20 function

  const erc20TransferAbi = [
    {
      inputs: [
        { type: 'address', name: 'to' },
        { type: 'uint256', name: 'amount' }
      ],
      name: 'transfer',
      outputs: [{ type: 'bool' }],
      stateMutability: 'nonpayable',
      type: 'function'
    },
    {
      inputs: [
        { type: 'address', name: 'spender' },
        { type: 'uint256', name: 'amount' }
      ],
      name: 'approve',
      outputs: [{ type: 'bool' }],
      stateMutability: 'nonpayable',
      type: 'function'
    },
    {
      inputs: [],
      name: 'decimals',
      outputs: [{ type: 'uint8' }],
      stateMutability: 'view',
      type: 'function'
    },
    {
      inputs: [],
      name: 'symbol',
      outputs: [{ type: 'string' }],
      stateMutability: 'view',
      type: 'function'
    }
  ] as const;