> For a complete page index, fetch https://docs.conduit.xyz/llms.txt

# Agent Skills

Give your AI coding agent full knowledge of every Conduit RPC API with a single command. Once installed, your agent knows every endpoint, network, authentication flow, and payment pattern without any manual prompting.

Skills work with [Claude Code](https://www.anthropic.com/claude-code), [Codex](https://openai.com/index/codex/), [Cursor](https://cursor.com), [VS Code Copilot](https://code.visualstudio.com/docs/copilot/overview), and any AI tool that supports the [Agent Skills specification](https://agentskills.io).

## Install the skill

```bash
npx skills add conduitxyz/skills --yes
```

This installs the `conduit-rpc-gateway` skill, which teaches your agent how to make paid JSON-RPC calls to 60+ networks on [Conduit Nodes](https://hub.conduit.xyz/) using [MPP](https://mpp.dev/overview) payment channels via [Tempo](https://tempo.xyz).

| Skill                 | Auth method                 | Best for                                                             |
| --------------------- | --------------------------- | -------------------------------------------------------------------- |
| `conduit-rpc-gateway` | MPP session (USDC on Tempo) | Agents that need RPC access to any Conduit rollup without an API key |

After installation, your agent will walk you through wallet setup and handle authentication automatically.

## What's included

The skill covers the full Conduit RPC gateway surface:

* **EVM JSON-RPC:** Standard methods (`eth_blockNumber`, `eth_getBalance`, `eth_call`, `eth_getLogs`, `eth_sendRawTransaction`, and more) across all Conduit networks
* **60+ Networks:** All networks listed on the [Conduit Hub](https://hub.conduit.xyz) or configured as discoverable are automatically supported. This includes 60+ networks such as Tempo, Plume, and Polygon Katana.
* **Payment flow:** Automatic MPP session management -- payment channels, signed vouchers, and settlement
* **Discovery:** Programmatic network discovery via `GET /openapi.json` and `GET /llms.txt`
* **Error handling:** Guidance for `402 Payment Required`, `404 Not Found`, and JSON-RPC error responses

The skill includes endpoint URLs, authentication patterns, code examples, CLI workflows, and network routing conventions.

## How it works

The `conduit-rpc-gateway` skill uses pay-as-you-go payment channels instead of API keys. Your agent authenticates by opening a USDC payment channel on Tempo, then sends signed off-chain vouchers with each request -- no gas fees after the first transaction.

**Cost:** \$0.00005 per JSON-RPC call (\~20,000 requests per 1 USDC).

**Gateway URL:** `https://mpp.conduit.xyz`

**Route format:** `POST https://mpp.conduit.xyz/:network-id`

### Payment flow

1. Your agent sends a JSON-RPC request to `/:network-id`
2. The server returns `402 Payment Required` with a `WWW-Authenticate: Payment` header
3. The client opens a payment channel on-chain (first request only)
4. Subsequent requests include a signed voucher -- no gas, no block confirmation, instant
5. Call `session.close()` to settle on-chain; unused deposit is refunded

### Choose a client

Your agent will prompt you to choose a client before making any RPC requests:

1. **Tempo Wallet** (Recommended) -- Managed MPP client with built-in spend controls. No manual key management.
2. **mppx** -- Lightweight MPP client via `npx`. Manages keys internally.

### Set up and fund your wallet

#### Install your chosen client

**Tempo Wallet:**

```bash
curl -fsSL https://tempo.xyz/install | bash
tempo wallet login
```

**mppx:**

```bash
npx mppx account create
```

#### Fund your wallet

Your wallet needs USDC on Tempo. At \$0.00005 per request, 1 USDC covers approximately 20,000 RPC calls.

#### Make your first request

**With Tempo Wallet:**

```bash
tempo request -X POST https://mpp.conduit.xyz/zora-mainnet-0 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'
```

**With mppx:**

```bash
npx mppx -X POST https://mpp.conduit.xyz/zora-mainnet-0 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'
```

## Supported methods

| Method                                    | Description                                      |
| ----------------------------------------- | ------------------------------------------------ |
| `debug_getBadBlocks`                      | Get a list of bad blocks seen on the network     |
| `debug_getRawBlock`                       | Get the RLP-encoded block                        |
| `debug_getRawHeader`                      | Get the RLP-encoded block header                 |
| `debug_getRawReceipts`                    | Get the RLP-encoded transaction receipts         |
| `debug_getRawTransaction`                 | Get the RLP-encoded transaction                  |
| `debug_traceCall`                         | Trace a call without creating a transaction      |
| `eth_accounts`                            | Get a list of addresses owned by the client      |
| `eth_blobBaseFee`                         | Get the base fee per blob gas in wei             |
| `eth_blockNumber`                         | Get the latest block number                      |
| `eth_call`                                | Execute a read-only contract call                |
| `eth_chainId`                             | Get the chain ID                                 |
| `eth_coinbase`                            | Get the client coinbase address                  |
| `eth_createAccessList`                    | Create an access list for a transaction          |
| `eth_estimateGas`                         | Estimate gas for a transaction                   |
| `eth_feeHistory`                          | Get fee history for a block range                |
| `eth_gasPrice`                            | Get the current gas price                        |
| `eth_getAccount`                          | Get account information for an address           |
| `eth_getBalance`                          | Get an address's native token balance            |
| `eth_getBlockByHash`                      | Get block data by block hash                     |
| `eth_getBlockByNumber`                    | Get block data by block number                   |
| `eth_getBlockReceipts`                    | Get all transaction receipts for a block         |
| `eth_getBlockTransactionCountByHash`      | Get transaction count in a block by hash         |
| `eth_getBlockTransactionCountByNumber`    | Get transaction count in a block by number       |
| `eth_getCode`                             | Get contract bytecode                            |
| `eth_getFilterChanges`                    | Poll a filter for new results                    |
| `eth_getFilterLogs`                       | Get all logs matching a filter ID                |
| `eth_getLogs`                             | Get event logs matching a filter                 |
| `eth_getProof`                            | Get account and storage Merkle proofs            |
| `eth_getRawTransactionByHash`             | Get raw transaction data by hash                 |
| `eth_getStorageAt`                        | Get a value from contract storage                |
| `eth_getTransactionByBlockHashAndIndex`   | Get a transaction by block hash and index        |
| `eth_getTransactionByBlockNumberAndIndex` | Get a transaction by block number and index      |
| `eth_getTransactionByHash`                | Get a transaction by hash                        |
| `eth_getTransactionCount`                 | Get an address's nonce                           |
| `eth_getTransactionReceipt`               | Get a transaction receipt                        |
| `eth_getUncleByBlockNumberAndIndex`       | Get an uncle block by number and index           |
| `eth_getUncleCountByBlockHash`            | Get uncle count in a block by hash               |
| `eth_getUncleCountByBlockNumber`          | Get uncle count in a block by number             |
| `eth_maxPriorityFeePerGas`                | Get the current max priority fee per gas         |
| `eth_newBlockFilter`                      | Create a filter for new blocks                   |
| `eth_newFilter`                           | Create a log filter                              |
| `eth_newPendingTransactionFilter`         | Create a filter for pending transactions         |
| `eth_protocolVersion`                     | Get the Ethereum protocol version                |
| `eth_sendRawTransaction`                  | Submit a signed transaction                      |
| `eth_sendRawTransactionConditional`       | Submit a signed transaction with conditions      |
| `eth_sendTransaction`                     | Submit a transaction                             |
| `eth_sign`                                | Sign data with an address                        |
| `eth_signTransaction`                     | Sign a transaction without submitting            |
| `eth_simulateV1`                          | Simulate transactions against virtual blocks     |
| `eth_subscribe`                           | Subscribe to real-time events                    |
| `eth_syncing`                             | Get sync status                                  |
| `eth_uninstallFilter`                     | Remove a filter                                  |
| `eth_unsubscribe`                         | Cancel a subscription                            |
| `net_listening`                           | Check if the client is listening for connections |
| `net_version`                             | Get the network ID                               |
| `web3_clientVersion`                      | Get the client version                           |
| `web3_sha3`                               | Compute a Keccak-256 hash                        |
| `alchemy_getTransactionReceipts`          | Get transaction receipts for a given block       |

## Example networks

| Network        | Route              |
| -------------- | ------------------ |
| Tempo          | `/tempo`           |
| Plume          | `/plume-mainnet-1` |
| Polygon Katana | `/katana`          |

Discover all available networks programmatically via [`/openapi.json`](https://mpp.conduit.xyz/openapi.json) or [`/llms.txt`](https://mpp.conduit.xyz/llms.txt).

## Programmatic usage

You can also use the `mppx/client` SDK to make paid RPC calls from your application:

```typescript
import { tempo } from 'mppx/client'
import { createClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { tempo as tempoChain } from 'viem/chains'

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)
const client = createClient({ account, chain: tempoChain, transport: http() })
const session = tempo.session({ client, maxDeposit: '1' })

const response = await session.fetch(
  'https://mpp.conduit.xyz/zora-mainnet-0',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method: 'eth_blockNumber',
      params: [],
      id: 1,
    }),
  }
)

const data = await response.json()
console.log(data)

// Close the session to settle on-chain; unused deposit is refunded
await session.close()
```

> **Info**
>
> Never hardcode private keys. Always read them from environment variables or a secure store.

A single payment session can make calls across different networks -- the channel is opened once, and subsequent requests to any network use the same signed vouchers.

## How skills work

Agent Skills follow an [open specification](https://agentskills.io/specification). A skill is a set of Markdown files that contain structured knowledge -- API docs, code examples, decision trees, and rules -- that an AI agent reads and follows.

When you run `npx skills add`, the skill files are added to your project. Your AI agent reads these files and uses them as context when writing code or making API requests.

|                    | Agent Skills                                      | MCP Server                                              |
| ------------------ | ------------------------------------------------- | ------------------------------------------------------- |
| **What it does**   | Teaches the agent *how* to use APIs               | Gives the agent *tools* to call APIs directly           |
| **When it's used** | When the agent writes code that uses Conduit APIs | When the agent needs to query live blockchain data      |
| **Output**         | The agent writes code using Conduit APIs          | The agent gets blockchain data back in the conversation |

## Next steps

#### [GitHub: conduitxyz/skills](https://github.com/conduitxyz/skills)

View the skill source and contribute.

#### [Conduit Hub](https://hub.conduit.xyz/)

Browse all supported networks.

#### [MPP Overview](https://mpp.dev/overview)

Learn about the Machine Payments Protocol.

#### [Agent Skills Spec](https://agentskills.io/specification)

Read the open Agent Skills specification.

> Give your AI coding agent full knowledge of Conduit RPC APIs with a single command.