# Quicknode RPC via x402

> Pay-per-request blockchain RPC access using the x402 payment protocol. Authenticate with SIWE (Ethereum) or SIWX (multi-chain including Solana), pay with stablecoin micropayments, and make JSON-RPC or REST calls to 140+ blockchain networks. No signup, no API keys — just a wallet.

## How it works

Quicknode RPC via x402 lets you access blockchain data through JSON-RPC and REST calls, paid for with stablecoin micropayments on Base, Polygon, XLayer (EVM) or Solana. Two payment models are available:

### Payment Models

1. **Per-request** ($0.001 USDC/USDG per request) — No authentication required. Send an x402 payment signature on each request. Best for AI agents and lightweight integrations.
2. **Nanopayment** ($0.0001 USDC per request via Circle Gateway) — Sub-cent payments, no authentication required. Requires USDC deposited in Circle Gateway Wallet contract. Detected by `extra.name === "GatewayWalletBatched"` in payment requirements (NOT a separate scheme — uses `scheme: "exact"`). EVM testnets only: Base Sepolia, Polygon Amoy, Arc Testnet. Usage draws from the shared monthly testnet credit cap (see below).
3. **Credit drawdown** (testnet: $1/100,000 credits, mainnet: $10/1,000,000 credits) — Authenticate via SIWX, receive JWT, consume credits per request. Best for high-volume usage.

### Credit Drawdown Flow
1. **Authenticate** — Sign a SIWE or SIWX message with your wallet and exchange it for a JWT token at `POST /auth`.
2. **Make RPC calls** — Send JSON-RPC or REST requests to `POST /:network` (or `/:network/*` for REST) with your JWT in the `Authorization: Bearer` header.
3. **Pay when prompted** — When credits run out, the server returns HTTP 402. The `@quicknode/x402` package (or `@x402/fetch` for manual setups) automatically signs a stablecoin payment and retries.
4. **Repeat** — Credits are consumed (1 per successful response). When exhausted, another 402 triggers a new payment automatically.

### Per-Request Flow
1. **Hit any endpoint with no auth** — The server returns HTTP 402 with payment requirements.
2. **Pay** — Send x402 payment signature ($0.001) on each request. No SIWX, no JWT needed.
3. **Access** — Each paid request is proxied immediately. No credits issued, no session.

> **Note:** Per-request and nanopayment are available for JSON-RPC and REST only — not for WebSocket or gRPC streaming connections. Use credit drawdown for persistent connections.

Base URL: `https://x402.quicknode.com`

**EVM (Base):** Testnet (Base Sepolia, chain ID 84532) and Mainnet (Base, chain ID 8453) are available. A `/drip` endpoint provides free testnet USDC for Base Sepolia.

**EVM (Polygon):** Testnet (Polygon Amoy, chain ID 80002) and Mainnet (Polygon, chain ID 137) are available. No `/drip` faucet for Polygon — pre-fund your wallet with USDC on Polygon Amoy.

**EVM (XLayer):** Testnet (XLayer Testnet, chain ID 1952) and Mainnet (XLayer, chain ID 196) are available. No `/drip` faucet for XLayer — pre-fund your wallet with USDG (Global Dollar by Paxos) on XLayer Testnet.

**EVM (Arc Testnet):** Chain ID 5042002 (`eip155:5042002`). Circle-native testnet supporting nanopayments. USDC ERC-20 uses standard 6 decimals (the native gas token uses 18 — do not mix them). No faucet — pre-fund your wallet with Arc Testnet USDC.

**Solana:** Devnet (`solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1`) and Mainnet (`solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`) are available. No faucet — pre-fund your wallet with USDC on Solana Devnet.

## Bootstrapping (no existing wallet needed)

### EVM (Base Sepolia — recommended for development)

1. **Generate a wallet** — Use `generatePrivateKey()` and `privateKeyToAccount()` from `viem/accounts` to create a fresh Ethereum keypair.
2. **Authenticate** — Sign a SIWE message and exchange it at `POST /auth` for a JWT (see Authentication section).
3. **Request testnet USDC** — Call `POST /drip` with your JWT. This is a one-time faucet that sends USDC to your wallet on Base Sepolia.
4. **Wait for USDC to arrive** — The faucet transaction is on-chain and takes a few seconds to confirm. Poll your wallet's USDC balance via `eth_call` on a public Base Sepolia RPC before proceeding.
5. **Make RPC calls** — Once your wallet has USDC, the `@x402/fetch` wrapper handles all subsequent payment negotiation automatically.

> **Tip:** Using `@quicknode/x402` with `preAuth: true` handles steps 2–5 automatically.

```typescript
import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';

// No existing key needed — generate one on the fly
const privateKey = generatePrivateKey();
const account = privateKeyToAccount(privateKey);
// Store privateKey securely — you will need it for future sessions
```

### Solana

1. **Generate a keypair** — Use `@solana/kit` or `tweetnacl` to generate an Ed25519 keypair, or use an existing Solana wallet.
2. **Pre-fund with USDC** — Transfer Solana Devnet USDC (mint: `4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU`) to your wallet. There is no `/drip` faucet for Solana.
3. **Authenticate via SIWX** — Construct a SIWX/Solana message and sign with Ed25519. POST to `/auth` with `type: "siwx"`.
4. **Make RPC calls** — Use `@x402/fetch` with `@x402/svm` for automatic Solana USDC payment handling.

## Authentication

All endpoints except `/auth` require a JWT Bearer token. The `/auth` endpoint supports three authentication paths:

### Path 1: Legacy SIWE (EVM only, backwards compatible)

POST `{ "message": "<SIWE string>", "signature": "0x<hex>" }` — no `type` field needed. The `message` is a standard EIP-4361 SIWE message. This is the original auth method and remains fully supported.

### Path 2: SIWX/EVM

POST `{ "message": "<SIWE string>", "signature": "0x<hex>", "type": "siwx" }`. The `message` follows the same EIP-4361 format as legacy SIWE. The `type: "siwx"` tells the server to use the SIWX verification path (functionally equivalent for EVM).

### Path 3: SIWX/Solana

POST `{ "message": "<SIWS string>", "signature": "<Base58>", "type": "siwx" }`. The `message` follows CAIP-122 / SIWS format:

```
x402.quicknode.com wants you to sign in with your Solana account:
<Base58 address>

I accept the Quicknode Terms of Service: https://www.quicknode.com/terms

URI: https://x402.quicknode.com
Version: 1
Chain ID: EtWTRABZaYq6iMfeYKouRu166VU2xqa1
Nonce: <random 8+ chars>
Issued At: <ISO 8601 timestamp>
```

Sign the message with Ed25519 and encode the signature as Base58.

### Required message fields (all paths)

- `domain`: `x402.quicknode.com`
- `address`: your wallet address (0x... for EVM, Base58 for Solana)
- `statement`: `I accept the Quicknode Terms of Service: https://www.quicknode.com/terms`
- `uri`: `https://x402.quicknode.com`
- `version`: `1`
- `chainId`: See Payment Configuration table for supported values
- `nonce`: at least 8 random characters (single-use)
- `issuedAt`: current ISO 8601 timestamp (must be within 5 minutes)

### Auth response

`{ "token": "<JWT>", "expiresAt": "<ISO datetime>", "accountId": "<CAIP-10 ID>" }`. The JWT expires in 1 hour. The `chainId` in the JWT is a CAIP-2 string (e.g., `"eip155:84532"` or `"solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1"`).

Include `Authorization: Bearer <JWT>` on all subsequent requests.

## Making RPC calls

Send a JSON-RPC or REST request to `POST /:network` (or `/:network/*` for REST):

```
POST /ethereum-mainnet HTTP/1.1
Authorization: Bearer <JWT>
Content-Type: application/json

{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}
```

Replace `ethereum-mainnet` with any supported network slug (see Supported Networks section). Note: the auth chain determines your payment method, not which networks you can query. A Solana-authed user can query EVM networks and vice versa.

When credits are available, you get the RPC response directly. When credits are depleted, you receive HTTP 402 with payment requirements in the response body and `PAYMENT-REQUIRED` header. The `@x402/fetch` library handles this automatically.

## x402 Payment handling

The x402 protocol uses HTTP 402 responses to negotiate payment. You can handle this manually or use the `@x402/fetch` npm package which automates the entire flow.

**Recommended: @quicknode/x402 package:**

Install: `npm install @quicknode/x402`

**Per-request mode (simplest, no auth):**
```typescript
import { createQuicknodeX402Client } from '@quicknode/x402';

const client = await createQuicknodeX402Client({
  baseUrl: 'https://x402.quicknode.com',
  network: 'eip155:84532',
  evmPrivateKey: '0xYOUR_PRIVATE_KEY',
  paymentModel: 'pay-per-request',
});

const response = await client.fetch('https://x402.quicknode.com/base-sepolia', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'eth_blockNumber', params: [] }),
});
```

**Credit drawdown mode (high-volume, with auth):**
```typescript
const client = await createQuicknodeX402Client({
  baseUrl: 'https://x402.quicknode.com',
  network: 'eip155:84532',
  evmPrivateKey: '0xYOUR_PRIVATE_KEY',
  paymentModel: 'credit-drawdown', // default if omitted
  preAuth: true,
});

// client.fetch handles auth, SIWX, payment, and session management automatically
const response = await client.fetch('https://x402.quicknode.com/base-sepolia', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'eth_blockNumber', params: [] }),
});
```

**Automatic handling with @x402/fetch (EVM):**

Install: `npm install @x402/fetch @x402/evm viem siwe`

```typescript
import { wrapFetchWithPayment, x402Client } from '@x402/fetch';
import { ExactEvmScheme, toClientEvmSigner } from '@x402/evm';

// Create an EVM signer from your wallet
const evmSigner = toClientEvmSigner({
  address: walletClient.account.address,
  signTypedData: (params) => walletClient.signTypedData(params),
});

// Register the signer for Base Sepolia
const client = new x402Client()
  .register('eip155:84532', new ExactEvmScheme(evmSigner));

// IMPORTANT: @x402/fetch passes a Request object (not url+init) on payment
// retries. The inner fetch must handle both calling conventions or the JWT
// will be silently dropped on the retry and the request will fail with 401.
const authedFetch = async (input: RequestInfo | URL, init?: RequestInit) => {
  if (input instanceof Request) {
    const req = input.clone();
    req.headers.set('Authorization', `Bearer ${jwtToken}`);
    return fetch(req);
  }
  const headers = new Headers(init?.headers);
  headers.set('Authorization', `Bearer ${jwtToken}`);
  return fetch(input, { ...init, headers });
};

const x402Fetch = wrapFetchWithPayment(authedFetch, client);

// Use x402Fetch like normal fetch — payments happen transparently
const response = await x402Fetch('https://x402.quicknode.com/base-sepolia', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'eth_blockNumber', params: [] }),
});
```

**Automatic handling with @x402/fetch (Solana):**

Install: `npm install @x402/fetch @x402/svm @solana/kit tweetnacl bs58`

```typescript
import { createKeyPairSignerFromBytes } from '@solana/kit';
import { wrapFetchWithPayment, x402Client } from '@x402/fetch';
import { ExactSvmScheme } from '@x402/svm';

// Create a Solana signer from your secret key (64 bytes)
const signer = await createKeyPairSignerFromBytes(secretKey);

// Register the signer for Solana Devnet
const client = new x402Client()
  .register('solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1', new ExactSvmScheme(signer));

const x402Fetch = wrapFetchWithPayment(authedFetch, client);

const response = await x402Fetch('https://x402.quicknode.com/solana-devnet', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getBlockHeight', params: [] }),
});
```

**Manual handling:**

When you receive HTTP 402, the response body contains an `accepts` array describing payment options. Each entry includes `network` (CAIP-2 chain ID), `amount` (in smallest unit), `payTo` (recipient address), and `asset` (token contract/mint address). For EVM, sign an EIP-712 typed data payment. For Solana, construct a partially-signed USDC transfer using the `feePayer` from the `extra` field. Include the payment as a base64-encoded `PAYMENT-SIGNATURE` header on your retry request.

**Payment configuration:**

Discover current payment requirements, supported networks, and pricing dynamically:
- `GET https://x402.quicknode.com/networks` — List all supported network slugs
- `GET https://x402.quicknode.com/discovery/resources` — Bazaar-compatible catalog with payment requirements per network
- `GET https://x402.quicknode.com/openapi.json` — OpenAPI 3.1 spec with x402 payment annotations

Each network returns payment options in the `accepts` array:
1. **Credit drawdown** (higher amount) — Testnet: $1 = 100,000 credits. Mainnet: $10 = 1,000,000 credits.
2. **Per-request** (lower amount, $0.001).
3. **Nanopayment** ($0.0001, only on eligible EVM testnets) — Identified by `extra.name === "GatewayWalletBatched"` and `extra.version === "1"`. Uses `maxTimeoutSeconds: 604900` (~7 days, Circle Gateway's minimum authorization validity). Requires USDC deposited in Circle Gateway Wallet (`0x0077777d7EBA4688BDeF3E311b846F25870A19B9`). Client usage: `paymentModel: 'nanopayment'` in `@quicknode/x402` config.

All three testnet payment methods draw from a single shared monthly cap of 1,000,000 credits per wallet (resets 00:00 UTC on the 1st). Mainnet is uncapped.

## x402 Extension-Based Authentication (SIWX Header)

For x402-native agents, a fully self-describing flow is available — no out-of-band knowledge of the `/auth` endpoint needed:

1. **Hit any endpoint with no auth** — The server returns HTTP 402 with `extensions` in the response body and `PAYMENT-REQUIRED` header.
2. **Read the `sign-in-with-x` extension** — Contains a SIWX challenge with `domain`, `uri`, `nonce`, `issuedAt`, `expirationTime`, and `supportedChains` (all EVM + Solana chains).
3. **Sign the SIWX challenge** — Construct a SIWX message from the challenge params, sign with your wallet, and encode as a `SIGN-IN-WITH-X` header (Base64-encoded JSON).
4. **Pay** — Include `PAYMENT-SIGNATURE` header with the x402 payment. The settlement response contains a `quicknode-session` extension with a JWT.
5. **Extract JWT from settlement** — Read `extensions['quicknode-session'].info.token` from the `PAYMENT-RESPONSE` header and use as `Authorization: Bearer <token>` for subsequent requests.

### `SIGN-IN-WITH-X` header format

The header value is Base64-encoded JSON matching the `SIWxPayload` schema:

```json
{
  "type": "eip191",
  "domain": "x402.quicknode.com",
  "address": "0xYourAddress",
  "uri": "https://x402.quicknode.com/ethereum-mainnet",
  "version": "1",
  "chainId": "eip155:8453",
  "nonce": "abc123...",
  "issuedAt": "2026-01-01T00:00:00.000Z",
  "signature": "0x..."
}
```

For Solana, use `"type": "ed25519"` and Base58 signature. Smart wallets (EIP-1271/6492) are supported on EVM chains.

### 402 Response Extensions

Every 402 response includes these extensions:

- **`sign-in-with-x`**: SIWX challenge with `info` (domain, uri, nonce, issuedAt, expirationTime, resources) and `supportedChains` array. Nonce expires in 5 minutes.
- **`bazaar`**: JSON-RPC POST input schema (`jsonrpc`, `method`, `params`, `id`) and example output (`{ jsonrpc: "2.0", result: "0x1234567", id: 1 }`).
- **`quicknode-session`**: Declares that a JWT will be issued in the settlement response at `extensions.quicknode-session.info.token`. Includes `expirySeconds`, `authEndpoint` (`/auth`), and `usage` (`Authorization: Bearer <token>`). All fields are nested under `info` per x402 extension convention.

### Discovery Endpoints

`GET /openapi.json` — Public, no auth required. Returns an OpenAPI 3.1 spec with `x-agentcash-auth` and `x-payment-info` annotations on payable routes. This is the canonical x402 discovery method.

`GET /discovery/resources` — Public, no auth required. Returns a paginated Bazaar-compatible catalog of all ~137 supported network endpoints with pricing and JSON-RPC schema.

Query parameters: `limit` (default 50, max 200), `offset` (default 0).

## Checking credits

```
GET /credits HTTP/1.1
Authorization: Bearer <JWT>
```

Returns `{ "accountId": "<CAIP-10>", "credits": 95 }`.

## Testnet faucet

Request free testnet USDC (one-time per account, **Base Sepolia (EVM) only** — no Polygon, XLayer, or Solana faucet):

```
POST /drip HTTP/1.1
Authorization: Bearer <JWT>
```

Returns `{ "accountId": "...", "walletAddress": "0x...", "transactionHash": "0x..." }`.

Polygon, XLayer, and Solana-authed users will receive 401 from `/drip`. Pre-fund your wallet with the appropriate stablecoin (USDC for Polygon, USDG for XLayer) on the respective testnet before authenticating.

## Endpoints

- `POST /auth` — Exchange SIWE/SIWX message + signature for JWT (public, no auth). Optional `type: "siwx"` field for multi-chain auth.
- `GET /credits` — Check credit balance (JWT required)
- `POST /drip` — Request testnet USDC (JWT required, Base Sepolia only, one-time)
- `GET /networks` — List all supported network slugs (public, rate limited)
- `POST /:network` — JSON-RPC/REST proxy to Quicknode (JWT or SIWX header + x402 payment). Anonymous requests return 402 with extensions.
- `GET /:network/ws` — WebSocket proxy for persistent JSON-RPC (JWT required, credits must exist)
- `GET /sql/rest/v1/clusters` — List Quicknode SQL Explorer clusters (public, 1-hour CDN cached)
- `GET /sql/rest/v1/schema` / `GET /sql/rest/v1/schema/:clusterId` — List / inspect SQL Explorer schemas (public, 1-hour CDN cached)
- `ALL /sql/rest/*` — Paid SQL Explorer REST pass-through (SIWX drawdown only; per-request `PAYMENT-SIGNATURE` is NOT accepted)
- `GET /discovery/resources` — Bazaar-compatible catalog of all supported networks (public, no auth)
- `GET /openapi.json` — OpenAPI 3.1 spec with x402 payment annotations (public, no auth)

## SQL Explorer

Quicknode SQL Explorer is a REST query API over indexed blockchain data (`https://api.quicknode.com/sql/rest`), exposed here as a 1:1 pass-through at `https://x402.quicknode.com/sql/rest/*` (every path mirrors upstream exactly).

**Free discovery endpoints** (no auth, 1-hour CDN cache): `GET /sql/rest/v1/clusters`, `GET /sql/rest/v1/schema`, `GET /sql/rest/v1/schema/:clusterId`.

**Paid endpoints** (`ALL /sql/rest/*`, e.g. `POST /sql/rest/v1/query`): require SIWX-authenticated credit drawdown. Cost is variable — each query consumes the number of SQL credits returned in the response, debited 1:1 from your drawdown balance. Because the cost is only known after the query runs, per-request `PAYMENT-SIGNATURE` is not accepted on `/sql/rest/*` — authenticate via SIWX and pre-fund credits instead. An unauthenticated request (or one presenting only `PAYMENT-SIGNATURE`) returns 402 with the SIWX drawdown extension and error `use-drawdown`.

## Rate limits

- `/auth`: 10 requests per 10 seconds per IP
- `/credits`: 50 requests per 10 seconds per account
- `/drip`: 5 requests per 60 seconds per account
- `/networks`: 10 requests per 10 seconds per IP
- `/:network`: 1,000 requests per 10 seconds per network:account pair

## Metering

- JSON-RPC/REST: 1 credit per successful (HTTP 200) response
- WebSocket: 1 credit per successful JSON-RPC response message
- Error responses and JSON-RPC errors are not metered

## Error responses

All errors return JSON: `{ "error": "<code>", "message": "<description>" }`.

Common error codes: `invalid_json`, `missing_params`, `missing_token`, `invalid_token`, `token_expired`, `unsupported_network`, `rate_limit_exceeded`, `monthly_limit_reached`.

Testnet accounts share a single pooled monthly cap of 1,000,000 credits per wallet across every payment method (credit drawdown, per-request, nanopayment) and resource type (RPC, SQL Explorer, WebSocket, gRPC). One simple JSON-RPC request consumes 1 credit; heavier operations draw more. The pool resets to 0 at 00:00 UTC on the 1st of each UTC calendar month. When exhausted, requests return 403 `monthly_limit_reached` until the reset — switch to a mainnet-funded wallet for uninterrupted access. Mainnet is uncapped.

## Supported Networks

Discover all supported network slugs dynamically via `GET https://x402.quicknode.com/networks`. This returns the full list of 140+ supported networks (EVM and non-EVM) including all testnets.

For detailed per-network payment requirements, use `GET https://x402.quicknode.com/discovery/resources` (paginated, supports `limit` and `offset` query parameters).

## Complete TypeScript example (EVM)

```typescript
import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { baseSepolia } from 'viem/chains';
import { SiweMessage, generateNonce } from 'siwe';
import { wrapFetchWithPayment, x402Client } from '@x402/fetch';
import { ExactEvmScheme, toClientEvmSigner } from '@x402/evm';

const BASE_URL = 'https://x402.quicknode.com';

// 1. Set up wallet
const walletClient = createWalletClient({
  account: privateKeyToAccount('0xYOUR_PRIVATE_KEY'),
  chain: baseSepolia,
  transport: http(),
});

// 2. Authenticate with SIWE
const siweMessage = new SiweMessage({
  domain: 'x402.quicknode.com',
  address: walletClient.account.address,
  statement: 'I accept the Quicknode Terms of Service: https://www.quicknode.com/terms',
  uri: BASE_URL,
  version: '1',
  chainId: 84532,
  nonce: generateNonce(),
  issuedAt: new Date().toISOString(),
});

const message = siweMessage.prepareMessage();
const signature = await walletClient.signMessage({ message });

const authResponse = await fetch(`${BASE_URL}/auth`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ message, signature }),
});
const { token } = await authResponse.json();

// 3. Create x402-enabled fetch (handles payments automatically)
const evmSigner = toClientEvmSigner({
  address: walletClient.account.address,
  signTypedData: (params) => walletClient.signTypedData(params),
});

const client = new x402Client()
  .register('eip155:84532', new ExactEvmScheme(evmSigner));

// IMPORTANT: @x402/fetch passes a Request object (not url+init) on payment
// retries, so the inner fetch must handle both calling conventions.
const authedFetch = async (input: RequestInfo | URL, init?: RequestInit) => {
  if (input instanceof Request) {
    const req = input.clone();
    req.headers.set('Authorization', `Bearer ${token}`);
    return fetch(req);
  }
  const headers = new Headers(init?.headers);
  headers.set('Authorization', `Bearer ${token}`);
  return fetch(input, { ...init, headers });
};

const x402Fetch = wrapFetchWithPayment(authedFetch, client);

// 4. Make RPC calls — payment is automatic on 402
const response = await x402Fetch(`${BASE_URL}/base-sepolia`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'eth_blockNumber',
    params: [],
  }),
});

const { result } = await response.json();
console.log('Block number:', BigInt(result));

// 5. Check remaining credits
const creditsResponse = await fetch(`${BASE_URL}/credits`, {
  headers: { Authorization: `Bearer ${token}` },
});
const { credits } = await creditsResponse.json();
console.log('Credits remaining:', credits);
```

## npm packages

- `@quicknode/x402` — Official Quicknode x402 client package. Handles SIWX authentication, x402 USDC payments, JWT session management, gRPC-Web transport, and WebSocket connections. Recommended for all new integrations.
- `@x402/fetch` — Wraps `fetch` to automatically handle 402 payment negotiation
- `@x402/evm` — EVM payment scheme (EIP-712 signing) for x402
- `@x402/svm` — Solana payment scheme (SPL Token transfer) for x402
- `viem` — Ethereum wallet client, signing, and chain utilities
- `siwe` — Sign-In with Ethereum (EIP-4361) message construction and signing
- `@solana/kit` — Solana SDK (for creating keypair signers used by @x402/svm)
- `tweetnacl` — Ed25519 cryptography (keypair generation, SIWX message signing)
- `bs58` — Base58 encoding/decoding for Solana keys and signatures

## Optional

### Additional documentation

- [Quicknode x402 Docs](https://www.quicknode.com/docs/build-with-ai/x402-payments) — Quicknode guide to x402 payments
- [x402 on Quicknode: Access Quicknode endpoints with x402 payments](https://www.quicknode.com/guides/x402/access-quicknode-endpoints-with-x402-payments): Quicknode's technical guide on x402
- [x402 on Quicknode: Instant Blockchain Access for Developers and AI Agents](https://blog.quicknode.com/x402-micropayments-quicknode-rpc-endpoints/): Quicknode's announcement blog post on x402
- [x402 Protocol](https://www.x402.org/): The x402 payment protocol specification
- [SIWE (EIP-4361)](https://eips.ethereum.org/EIPS/eip-4361): Sign-In with Ethereum standard
- [CAIP-122](https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-122.md): Sign-In with X (SIWX) standard