How to Send an Express Lane Transaction Using timeboost_sendExpressLaneTransaction

Use the NitroNodeClient.sendExpressLaneTransaction method in the arbitrum-mcp SDK, which forwards a signed transaction payload to the node's JSON-RPC method timeboost_sendExpressLaneTransaction for priority processing.

The TimeBoost API enables priority transaction processing on Arbitrum through the express lane, bypassing standard mempool delays. In the arbitrum-mcp repository, this capability is exposed via the timeboost_sendExpressLaneTransaction JSON-RPC method, wrapped by a TypeScript client for seamless integration. This guide demonstrates how to construct transaction payloads and send them through the express lane using the official SDK implementation.

How timeboost_sendExpressLaneTransaction Works

The timeboost_sendExpressLaneTransaction method is the core JSON-RPC endpoint that accepts signed transaction payloads for priority inclusion. The arbitrum-mcp SDK abstracts this complexity through two primary architectural layers.

The NitroNodeClient Implementation

Located in src/clients/nitro-node-client.ts, the NitroNodeClient class provides a thin wrapper around the raw RPC call. The sendExpressLaneTransaction method accepts a submission object and forwards it via makeRpcCall to the node's timeboost_sendExpressLaneTransaction endpoint at lines 46-63.

If the node does not support the TimeBoost API, the client catches the exception and returns a structured error object rather than throwing. This ensures graceful degradation when interacting with standard RPC endpoints.

The MCP Command Handler Layer

The McpCommandHandler in src/index.ts (lines 84-92) provides the high-level interface used by CLI and HTTP JSON-RPC consumers. It resolves RPC endpoints through resolveRpcUrl (implemented in src/services/chain-lookup.ts), instantiates NitroNodeClient, and forwards the submission payload. This handler supports both raw RPC URLs and human-readable chain names like "Arbitrum One".

Sending an Express Lane Transaction: Code Examples

Direct Client Usage

For programmatic integration, instantiate NitroNodeClient directly with a TimeBoost-enabled RPC endpoint:

import { NitroNodeClient } from './src/clients/nitro-node-client';

const rpcUrl = 'https://arb1.arbitrum.io/rpc'; // TimeBoost-enabled node
const client = new NitroNodeClient(rpcUrl);

const submission = {
  txData: '0x02f8...', // RLP-encoded signed transaction
  maxFeePerGas: '0x0de0b6b3a7640000',
  maxPriorityFeePerGas: '0x0ba43b7400',
  gasLimit: '0x5208'
};

const result = await client.sendExpressLaneTransaction(submission);
console.log(result.success ? 'Accepted' : `Failed: ${result.error}`);

The sendExpressLaneTransaction method internally calls timeboost_sendExpressLaneTransaction according to the implementation in src/clients/nitro-node-client.ts.

Using the MCP Command Handler

For CLI or server-based workflows, use the higher-level handler that manages endpoint resolution:

import { McpCommandHandler } from './src/index';

const handler = new McpCommandHandler();
const args = {
  rpcUrl: 'https://arb1.arbitrum.io/rpc',
  submission: {
    txData: '0x02f8...',
    maxFeePerGas: '0x0de0b6b3a7640000',
    maxPriorityFeePerGas: '0x0ba43b7400',
    gasLimit: '0x5208'
  }
};

const result = await handler.handle('timeboost_sendExpressLaneTransaction', args);
console.log(JSON.stringify(result, null, 2));

This approach leverages the chain lookup service in src/services/chain-lookup.ts to resolve endpoints and returns JSON-RPC-compatible responses.

Handling the Response

The SDK returns a standardized response object. Successful submissions return:

{
  "success": true
}

Failed attempts, including unsupported endpoints, return structured error data:

{
  "success": false,
  "error": "Express lane transaction not supported on this RPC endpoint"
}

Summary

• The timeboost_sendExpressLaneTransaction JSON-RPC method enables priority transaction processing in Arbitrum's express lane.
• NitroNodeClient in src/clients/nitro-node-client.ts wraps the raw RPC call and handles error normalization.
• McpCommandHandler in src/index.ts provides the high-level interface with automatic RPC URL resolution via src/services/chain-lookup.ts.
• The submission payload requires txData, maxFeePerGas, maxPriorityFeePerGas, and optional gasLimit fields.
• Responses follow a consistent { success: boolean, error?: string } pattern for reliable error handling.

Frequently Asked Questions

What is the Arbitrum Express Lane?

The express lane is a priority transaction pathway in Arbitrum that bypasses standard mempool congestion. Transactions submitted via timeboost_sendExpressLaneTransaction receive faster processing guarantees compared to regular L2 transactions, provided the node supports the TimeBoost API.

What parameters are required in the submission object?

The submission object must include txData (the RLP-encoded signed transaction hex), maxFeePerGas, and maxPriorityFeePerGas. The gasLimit field is optional. The SDK delegates additional validation to the node itself rather than enforcing schema constraints client-side.

How do I verify my RPC endpoint supports TimeBoost?

Attempt a call to timeboost_sendExpressLaneTransaction using NitroNodeClient. If the method is unsupported, the client returns { success: false, error: "Express lane transaction not supported..." } rather than throwing an exception. Verify your node provider explicitly supports the TimeBoost API before production use.

Can I use chain names instead of raw RPC URLs?

Yes. The McpCommandHandler accepts either a raw rpcUrl or a human-readable chainName (e.g., "Arbitrum One"). It resolves the name to an endpoint via the resolveRpcUrl function in src/services/chain-lookup.ts, simplifying configuration across different environments.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}