# How to Send an Express Lane Transaction Using timeboost_sendExpressLaneTransaction

> Learn to send an express lane transaction using NitroNodeClient.sendExpressLaneTransaction in the arbitrum-mcp SDK for priority processing via timeboost_sendExpressLaneTransaction JSON-RPC.

- Repository: [Dewansh/arbitrum-mcp](https://github.com/dewanshparashar/arbitrum-mcp)
- Tags: how-to-guide
- Published: 2026-02-28

---

**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`](https://github.com/dewanshparashar/arbitrum-mcp/blob/main/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`](https://github.com/dewanshparashar/arbitrum-mcp/blob/main/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`](https://github.com/dewanshparashar/arbitrum-mcp/blob/main/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:

```typescript
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`](https://github.com/dewanshparashar/arbitrum-mcp/blob/main/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:

```typescript
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`](https://github.com/dewanshparashar/arbitrum-mcp/blob/main/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:

```json
{
  "success": true
}

```

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

```json
{
  "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`](https://github.com/dewanshparashar/arbitrum-mcp/blob/main/src/clients/nitro-node-client.ts) wraps the raw RPC call and handles error normalization.
- **McpCommandHandler** in [`src/index.ts`](https://github.com/dewanshparashar/arbitrum-mcp/blob/main/src/index.ts) provides the high-level interface with automatic RPC URL resolution via [`src/services/chain-lookup.ts`](https://github.com/dewanshparashar/arbitrum-mcp/blob/main/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`](https://github.com/dewanshparashar/arbitrum-mcp/blob/main/src/services/chain-lookup.ts), simplifying configuration across different environments.