Skip to main content
Glama
dewanshparashar

Arbitrum MCP Server

arbdebug_validationInputsAt

Retrieve validation inputs for specific messages on Arbitrum networks to debug and verify transaction processing using debug APIs.

Instructions

Get validation inputs at a specific message (requires debug API)

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
rpcUrlNoThe RPC URL of the Arbitrum node (optional if default is set)
chainNameNoChain name (e.g., 'Xai', 'Arbitrum One') - will auto-resolve to RPC URL
msgNumYesMessage number to get validation inputs for
targetNoTarget for validation inputs

Implementation Reference

  • MCP tool handler for 'arbdebug_validationInputsAt': resolves RPC URL from args or chainName, instantiates NitroNodeClient, calls getValidationInputsAt(msgNum, target), returns JSON-formatted result.
    case "arbdebug_validationInputsAt": {
      const rpcUrl = await this.resolveRpcUrl(
        (args.rpcUrl as string) || (args.chainName as string)
      );
      const nodeClient = new NitroNodeClient(rpcUrl);
      const result = await nodeClient.getValidationInputsAt(
        args.msgNum as number,
        args.target as string
      );
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(result, null, 2),
          },
        ],
      };
    }
  • src/index.ts:1435-1462 (registration)
    Tool registration in getAvailableTools(): defines name, description, and inputSchema (rpcUrl optional, chainName optional, msgNum required, target optional). Returned by ListTools handler.
      name: "arbdebug_validationInputsAt",
      description:
        "Get validation inputs at a specific message (requires debug API)",
      inputSchema: {
        type: "object" as const,
        properties: {
          rpcUrl: {
            type: "string",
            description:
              "The RPC URL of the Arbitrum node (optional if default is set)",
          },
          chainName: {
            type: "string",
            description:
              "Chain name (e.g., 'Xai', 'Arbitrum One') - will auto-resolve to RPC URL",
          },
          msgNum: {
            type: "number",
            description: "Message number to get validation inputs for",
          },
          target: {
            type: "string",
            description: "Target for validation inputs",
          },
        },
        required: ["msgNum"],
      },
    },
  • Input schema definition for the tool: object with optional rpcUrl/chainName, required msgNum (number), optional target (string).
      type: "object" as const,
      properties: {
        rpcUrl: {
          type: "string",
          description:
            "The RPC URL of the Arbitrum node (optional if default is set)",
        },
        chainName: {
          type: "string",
          description:
            "Chain name (e.g., 'Xai', 'Arbitrum One') - will auto-resolve to RPC URL",
        },
        msgNum: {
          type: "number",
          description: "Message number to get validation inputs for",
        },
        target: {
          type: "string",
          description: "Target for validation inputs",
        },
      },
      required: ["msgNum"],
    },
  • Helper method in NitroNodeClient: converts msgNum to hex, optionally adds target, calls RPC 'arbdebug_validationInputsAt', returns inputs or error.
    async getValidationInputsAt(
      msgNum: number,
      target?: string
    ): Promise<ValidationInputs> {
      try {
        const params = [`0x${msgNum.toString(16)}`];
        if (target) {
          params.push(target);
        }
    
        const inputs = await this.makeRpcCall(
          "arbdebug_validationInputsAt",
          params
        );
        return { inputs };
      } catch (error) {
        return {
          inputs: null,
          error: `Validation inputs not supported on this RPC endpoint: ${
            (error as Error).message
          }`,
        };
      }
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only states what the tool does ('Get validation inputs') and mentions 'requires debug API' as a prerequisite. It doesn't disclose important behavioral traits such as whether this is a read-only operation, potential rate limits, authentication requirements, what 'validation inputs' actually returns, or any side effects. For a tool with no annotations, this is insufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that states the core purpose and includes an important prerequisite ('requires debug API'). It's appropriately sized for what it covers, though it could be more front-loaded with additional context. There's no wasted verbiage or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of debugging/validation tools in blockchain contexts, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'validation inputs' are, what format they return, error conditions, or how this differs from similar debugging tools. For a tool that likely returns complex debugging data, more context is needed to help an agent use it effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all four parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain relationships between parameters (like how chainName and rpcUrl interact), doesn't clarify what 'target' means in context, or provide examples. With complete schema coverage, the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the tool 'Get validation inputs at a specific message' which provides a verb ('Get') and resource ('validation inputs'), but it's vague about what 'validation inputs' actually are in the context of Arbitrum. It mentions 'requires debug API' which adds some context but doesn't clearly differentiate this tool from siblings like 'arbdebug_validateMessageNumber' or 'arbtrace' tools that might also involve message validation or debugging.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. While it mentions 'requires debug API', this doesn't specify use cases, prerequisites, or exclusions compared to sibling tools like 'arbdebug_validateMessageNumber' or other debugging/tracing tools. There's no mention of specific scenarios where this tool is appropriate versus others.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/dewanshparashar/arbitrum-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server