# x402-v2 — Guía para Agents e Integradores

**Estado:** Completada · discovery v1.12.0 (29 Ago 2026)  
**Dominio:** `server/services/x402-v2/`  
**Checklist:** #12 — guía agents / integradores  
**NFA:** el Templo vende **inteligencia de mercado / análisis**. Nunca órdenes de compra, venta ni ejecución de trades. Ningún AccessPass constituye consejo financiero.

Esta guía es el contrato operativo para un agent autónomo (o un integrador humano que lo cablea). No requiere dominio público: todo funciona contra `localhost` o el `baseUrl` del manifiesto.

**Live (sin auth):** `GET /x402/hello` · `GET /x402/schema` · `GET /llms.txt` · `GET /llms-full.txt` · `GET /x402/docs` · `GET /.well-known/x402`.

**Por qué este Templo:** multi-dios (no un scrape único) · ladder desde $0.02 · AccessPass 24h · verify idempotente · rails honestos (solo Solana en `chainsAccepted`).

`temple_verify` es **idempotente**: si el pago ya se verificó, reintenta verify y recuperas el mismo AccessPass. **No pagues dos veces.** Una tx no se puede reutilizar en otro `requestId` (`tx_replay`).

No cubre: listing OpenDexter/x402scan (OPS-4), settle Base/BNB live, facilitators EVM, Temis/swarm interno, ni cobros humanos (La Daga / El Santuario).

---

## 0. Qué es el Templo (en una frase)

El Templo es un catálogo **pay-per-query** en **Solana USDC SPL**. El agent:

1. Descubre SKUs y precios.
2. Pide un tributo (`requestTribute`).
3. Paga on-chain al vault x402 (memo del request).
4. Verifica (`verify`) → recibe **AccessPass** + **Receipt**.
5. Reutiliza el pass (`validate` / `consume`) hasta agotar usos, cap o caducidad.

Pagos humanos (suscripción) **no** son este flujo. Vault x402 ≠ vault de La Daga.

---

## 1. Cómo descubrir el Templo

Sin índice público (OpenDexter) el agent necesita una URL base. En local:

```text
http://localhost:3000
```

En deploy, `PUBLIC_APP_URL` (aún no obligatorio para integrar).

### 1.1 Manifiesto (fuente de verdad de discovery)

```http
GET /x402/hello
GET /x402/schema
GET /.well-known/x402
GET /x402/manifest
GET /x402-manifest.json
```

`GET /x402/hello` es el pack de 10 segundos. `GET /x402/schema` es JSON Schema + playbook (valida payloads antes de pagar). Compártelo con agents amigos. **No** es listing OpenDexter.

Equivalente tRPC público:

```text
GET /api/trpc/x402V2.getManifest
GET /api/trpc/x402V2.listCatalog
GET /api/trpc/x402V2.mcpTools
```

El JSON incluye: `chain: "solana"`, `asset: "USDC"`, `usdcMint`, `cluster`, `nfa: true`, `nfaDisclaimer`, `skus[]`, `featuredSkus[]`, `sessions.accessPass`, `spendingCaps`, `rateLimit`, `endpoints`, `mcp.tools`.

### 1.2 Health (gratis, sin x402)

```http
GET /x402/health
```

SKU documental: `temple.ping` · `priceUsdc: 0` · `paid: false`.

### 1.3 Auth agentica

Catálogo y manifiesto son **públicos**. Pago / verify / pass / receipts / budget requieren API key.

```bash
# multi-key
TEMPLE_AGENT_API_KEYS=mi_clave_secreta_larga:42

# o single
TEMPLE_AGENT_API_KEY=mi_clave_secreta_larga
TEMPLE_AGENT_USER_ID=42
```

Headers (uno de los dos):

```http
Authorization: Bearer <key>
X-Temple-Agent-Key: <key>
```

Humanos autenticados usan tRPC de sesión (`requestTribute` / `verifyAndGrant`) en lugar de MCP.

---

## 2. Flujo completo: requestTribute → pagar → verify → AccessPass

```text
┌─────────────┐    ┌──────────────────┐    ┌─────────────┐    ┌──────────────┐
│  Descubrir  │ →  │ requestTribute   │ →  │ Pagar USDC  │ →  │ verifyAndGrant│
│  catálogo   │    │ (TributeRequest) │    │ SPL + memo  │    │ grant+pass+rx │
└─────────────┘    └──────────────────┘    └─────────────┘    └──────┬───────┘
                                                                     │
                     ┌────────────────┐    ┌─────────────────┐       │
                     │ consume_pass   │ ←  │ validate_pass   │ ←─────┘
                     │ (lectura real) │    │ (sin gastar)    │
                     └────────────────┘    └─────────────────┘
```

### 2.1 Elegir SKU

Regla práctica:

| Objetivo | SKU | Precio |
|----------|-----|--------|
| Probar el Templo | `hermes.pulse` | 0.02 USDC |
| Flujo on-chain | `poseidon.flow` | 0.05 USDC |
| Señal estructurada | `delfos.signal` | 0.25 USDC |
| Varias lecturas / 24h | `session.24h` | 9.00 USDC (pack, 12 usos, SKUs ≤ $1.00, cap 12 USDC) |
| Informe único | `pantheon.deep_report` | 15.00 USDC (1 uso) |

Precios exactos: `server/services/x402-v2/catalog.ts` (`CANONICAL_PRICE_SNAPSHOT`). No negociar, no redondear a $0.50 legacy.

### 2.2 requestTribute

Crea un `TributeRequest` con `requestId`, `amountUsdc`, `recipientVault`, `memo`, `expiresAtIso`.

**MCP**

```http
POST /x402/mcp/temple_request_tribute
Content-Type: application/json
Authorization: Bearer <key>

{"sku":"hermes.pulse"}
```

**tRPC** (sesión humana)

```ts
const r = await trpc.x402V2.requestTribute.mutate({ sku: "hermes.pulse" });
// r.request.requestId, r.request.amountUsdc, r.request.recipientVault, r.request.memo
```

El Templo aplica **antes de firmar**:

- Allowlist (`TEMPLE_SKU_ALLOWLIST`, si existe)
- Cap por transacción (`TEMPLE_PER_TX_CAP_USDC`, default 15)
- Cap diario (`TEMPLE_DAILY_SPEND_CAP_USDC`, default 25)
- Rate limit + circuit breaker

Si el gate falla, **no pagues**. El error es tipado (`daily_cap`, `per_tx_cap`, `sku_not_allowed`, `allowlist_blocked`).

### 2.3 Pagar on-chain

Transferencia **SPL USDC** (no SOL nativo) al `recipientVault` del request.

Requisitos de verify:

- Mint = USDC SPL del manifiesto (`usdcMint`)
- Monto exacto = `amountUsdc` (raw 6 decimales)
- Destino = vault del request (vault x402, no el de suscripciones)
- Memo UTF-8 = `request.memo` (Programa Memo)
- `payerWallet` = firmante que el agent declarará en verify
- Tx confirmada, no demasiado antigua

El agent debe persistir: `requestId`, `txSignature`, `payerWallet`, `sku`.

### 2.4 verify → AccessPass

**MCP**

```http
POST /x402/mcp/temple_verify
Authorization: Bearer <key>
Content-Type: application/json

{
  "requestId": "<requestId>",
  "txSignature": "<sig>",
  "payerWallet": "<base58>"
}
```

**tRPC**

```ts
const v = await trpc.x402V2.verifyAndGrant.mutate({
  requestId,
  txSignature,
  payerWallet,
});
// v.pass.passId · v.grant · v.receipt.receiptId
```

Éxito: `{ grant, pass, receipt }`. Guarda `pass.passId` y `receipt.receiptId`.  
Fallo: `code: "verify_failed"` (u otro código) + `retryable` + `messages` i18n + NFA. **No reintentes el pago**; reintenta verify si la tx aún no está confirmada (`retryable: true`).

---

## 3. Cómo usar y consumir el AccessPass

Un AccessPass es una sesión HMAC. **No firmes de nuevo** mientras `status === "active"`, queden usos y no haya expirado.

### 3.1 Anatomía

| Campo | Uso |
|-------|-----|
| `passId` | Identidad. Guárdalo. |
| `purchasedSku` | SKU que se pagó |
| `allowedSkus` | SKUs canjeables (entry/premium = 1; pack = todos ≤ techo) |
| `maxUses` / `usesRemaining` | Cupo de lecturas |
| `expiresAtIso` | Caducidad absoluta |
| `spentUsdc` / `spendingCapUsdc` | Cap de gasto **del pass** (packs) |
| `kind` | `entry` \| `pack` \| `premium` |
| `integrity` | HMAC-SHA256 (no lo recalcules; el Templo lo verifica) |
| `nfa` | Siempre presente |

HMAC cubre identidad inmutable del pass (no cubre `usesRemaining` / `spentUsdc` a propósito: esos campos cambian en cada consume). Si `integrity` falla → `code: "integrity"` (no reintentar; el pass no es de confianza).

### 3.2 Validar (sin gastar)

```http
POST /x402/mcp/temple_validate_pass
{"passId":"<id>","sku":"hermes.pulse"}
```

```ts
await trpc.x402V2.validateAccessPass.query({ passId, sku: "hermes.pulse" });
```

Sirve para saber si `consume` va a pasar: SKU permitido, no expirado, usos, cap del pass, allowlist.

### 3.3 Consumir (lectura real)

```http
POST /x402/mcp/temple_consume_pass
{"passId":"<id>","sku":"hermes.pulse"}
```

```ts
await trpc.x402V2.consumeAccessPass.mutate({ passId, sku: "hermes.pulse" });
```

Efectos:

- `usesRemaining -= 1`
- `spentUsdc += precio catálogo del SKU consumido`
- Receipt `kind: "consume"`
- Si usos = 0 → `status: "exhausted"`

**Consume no vuelve a cobrar el cap diario.** El diario se debitó en el pago. El cap del pass (`spendingCapUsdc`) **solo aplica a packs**; entry/premium se limitan por `usesRemaining`.

### 3.4 Packs vs one-shot

| Kind | Ejemplo | Usos | Allowed | Cap pass |
|------|---------|------|---------|----------|
| entry | `hermes.pulse` | `maxQueries` del SKU | solo ese SKU | precio del SKU |
| pack | `session.24h` | **12** | SKUs ≤ **$1.00** (no packs) | **12 USDC** |
| premium | `pantheon.war_council` | ≤ 2 | solo ese | 6 USDC |
| premium one-shot | `pantheon.deep_report` | **1** | solo ese | 15 USDC |

> **12 Sep 2026 (Plan WIN):** pack canónico = 12 reads ≤ $1.00 · spendingCap 12 USDC · precio $9. Confluence contract: `GET /x402/hello` → `confluenceContract` (schema `criptonous.temple.confluence` v1.0.0).

Un pass one-shot agotado no se “recarga”. Hay que pagar otro tributo.

### 3.5 Receipts (élite, no DTE/SII)

El Receipt es un **comprobante comercial agentico**. No es boleta ni factura SII. `notFiscal: true` siempre. HMAC-SHA256 **v2**. NFA en 6 idiomas.

```http
GET  /x402/receipts/:receiptId
GET  /x402/receipts?limit=20
POST /x402/receipts/verify          { "receipt": { …JSON íntegro… } }
POST /x402/mcp/temple_get_receipt   {"receiptId":"<id>"}
POST /x402/mcp/temple_list_receipts {"limit":20}
```

```ts
await trpc.x402V2.getReceipt.query({ receiptId });
await trpc.x402V2.listMyReceipts.query({ limit: 20 });
await trpc.x402V2.listMyAuditTrail.query({ limit: 50 });
```

**Cómo verificar:** el agent **no** recalcula HMAC (no tiene el secret). `GET /x402/receipts/:id` ya valida integridad. Para un JSON guardado: `POST /x402/receipts/verify`. Si `code: "integrity"` → tamper, descartar. Si no existe → `code: "not_found"`. Owner mismatch → `forbidden`.

Contrato completo: `docs/X402_V2_RECEIPTS.md`.

---

## 4. Spending Budget / Caps

Hay **tres capas**. El agent debe consultarlas **antes** de un nuevo pago.

| Capa | Qué limita | Dónde |
|------|------------|-------|
| Política env | Diario / por tx / allowlist | `getSpendingBudget` / `temple_budget` |
| AccessPass | Usos + `spendingCapUsdc` + `allowedSkus` | el pass |
| Rate limit | req/min y req/día + circuit | 429 + `retryAfterSec` |

**MCP**

```http
GET  /x402/mcp/temple_budget
POST /x402/mcp/temple_budget
```

**tRPC**

```ts
const { tab } = await trpc.x402V2.getSpendingBudget.query();
// tab.dailyCapUsdc, tab.perTxCapUsdc, tab.spentUsdc, tab.remainingUsdc, tab.allowedSkus
```

Defaults (sobre-escribibles por env): diario **25 USDC**, por tx **15 USDC**, allowlist = catálogo completo.

Regla de oro:

```text
si remainingUsdc < sku.priceUsdc → no llames requestTribute
si sku.priceUsdc > perTxCapUsdc → no llames requestTribute
si allowlist no incluye sku → no llames requestTribute
si pass.usesRemaining === 0 o pass expirado → paga un pass nuevo
```

Consumir un pass **no** incrementa `tab.spentUsdc`. Superar el cap **del pass** (`spentUsdc + price > spendingCapUsdc`) sí bloquea el consume (`spend_cap_exceeded`) aunque queden usos.

---

## 5. Ejemplos de llamadas

Sustituye `BASE` por `http://localhost:3000` (o el `baseUrl` del manifiesto).

### 5.1 MCP — bootstrap y catálogo (público)

```bash
curl -s "$BASE/x402/mcp/tools"
curl -s "$BASE/x402/health"
curl -s -X POST "$BASE/x402/mcp/temple_catalog"
curl -s "$BASE/.well-known/x402"
```

### 5.2 MCP — tributo + verify + pass

```bash
# 1. Tribute
curl -s -X POST "$BASE/x402/mcp/temple_request_tribute" \
  -H "Authorization: Bearer $TEMPLE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sku":"session.24h"}'

# 2. (el agent paga USDC SPL con el memo del request)

# 3. Verify
curl -s -X POST "$BASE/x402/mcp/temple_verify" \
  -H "Authorization: Bearer $TEMPLE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"requestId":"...","txSignature":"...","payerWallet":"..."}'

# 4. Budget
curl -s -X POST "$BASE/x402/mcp/temple_budget" \
  -H "Authorization: Bearer $TEMPLE_KEY"

# 5. Validate + consume
curl -s -X POST "$BASE/x402/mcp/temple_validate_pass" \
  -H "Authorization: Bearer $TEMPLE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"passId":"...","sku":"hermes.pulse"}'

curl -s -X POST "$BASE/x402/mcp/temple_consume_pass" \
  -H "Authorization: Bearer $TEMPLE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"passId":"...","sku":"hermes.pulse"}'
```

Tools live: `temple_catalog`, `temple_request_tribute`, `temple_verify`, `temple_validate_pass`, `temple_consume_pass`, `temple_get_receipt`, `temple_list_receipts`, `temple_budget`.

### 5.3 tRPC

Procedimientos:

| Método | Auth | Uso |
|--------|------|-----|
| `x402V2.listCatalog` | público | SKUs + health |
| `x402V2.getManifest` | público | manifiesto |
| `x402V2.mcpTools` | público | descriptors MCP |
| `x402V2.listPrices` | público | precios |
| `x402V2.requestTribute` | sesión | TributeRequest |
| `x402V2.verifyAndGrant` | sesión | grant + pass + receipt |
| `x402V2.validateAccessPass` | sesión | validar |
| `x402V2.consumeAccessPass` | sesión | consumir |
| `x402V2.getReceipt` | sesión | receipt |
| `x402V2.listMyReceipts` | sesión | historial |
| `x402V2.listMyAuditTrail` | sesión | audit |
| `x402V2.getSpendingBudget` | sesión | caps |

Ejemplo (cliente tRPC):

```ts
const catalog = await trpc.x402V2.listCatalog.query();
const featured = catalog.paid.filter((s) => s.tags.includes("featured") || s.id === "hermes.pulse");

const tribute = await trpc.x402V2.requestTribute.mutate({ sku: "hermes.pulse" });
if (!tribute.success) throw new Error(tribute.message);

// ... pago Phantom / wallet ...

const granted = await trpc.x402V2.verifyAndGrant.mutate({
  requestId: tribute.request.requestId,
  txSignature,
  payerWallet,
});
if (!granted.success) {
  // granted.reason / granted.code
  throw new Error(granted.reason);
}

const passId = granted.pass.passId;
const used = await trpc.x402V2.consumeAccessPass.mutate({
  passId,
  sku: "hermes.pulse",
});
```

---

## 6. Errores comunes y cómo manejarlos

Todos los fallos agent-facing son JSON tipado:

```json
{
  "ok": false,
  "domain": "x402-v2",
  "code": "expired",
  "retryable": false,
  "retryAfterSec": null,
  "httpHint": 409,
  "message": "AccessPass expired. Request a new tribute.",
  "messages": { "es": "...", "en": "...", "ru": "...", "ja": "...", "ko": "...", "zh": "..." },
  "nfa": "NFA — Inteligencia de mercado / análisis. No es consejo financiero ni orden de compra/venta."
}
```

Usa **`code`**, no parsees `message`. `messages.{locale}` es UX; `message` está en inglés (contrato machine-readable).

| `code` | Cuándo | Qué hacer |
|--------|--------|-----------|
| `auth_required` | API key ausente/inválida | Configurar header. No reintentar el pago. |
| `auth_not_configured` | Server sin `TEMPLE_AGENT_*` | Ops: definir env. |
| `request_not_found` | `requestId` desconocido | Volver a `requestTribute`. No reusar tx vieja. |
| `request_expired` | TTL del request agotado | Nuevo tribute. La tx antigua no servirá (memo distinto). |
| `vault_mismatch` | Vault del request ≠ config | Abortar. No pagar a una address improvisada. |
| `verify_failed` | SPL/memo/monto/edad | Si tx no confirmada: esperar y re-verify. Si memo/monto mal: **nuevo** tribute. |
| `not_found` | `passId` / receipt desconocido | No inventar IDs. |
| `integrity` | HMAC inválido | Descartar pass. Posible tamper o secret rotado. |
| `expired` | `expiresAtIso` pasado (también mid-consume) | Nuevo pago. |
| `exhausted` | `usesRemaining === 0` | Nuevo pago o pack. |
| `revoked` | Pass revocado | Abortar. |
| `owner_mismatch` | Pass de otro user/agent | Usar la API key dueña del pass. |
| `sku_not_allowed` | SKU fuera de `allowedSkus` o techo del pack | Elige un SKU del pass. Packs no cubren `pantheon.deep_report`. |
| `allowlist_blocked` | `TEMPLE_SKU_ALLOWLIST` no incluye el SKU | Cambia SKU o pide ops que amplíe la lista. |
| `spend_cap_exceeded` | Cap **del pass** | Quedan usos pero no presupuesto del pack. Nuevo pack o SKU más barato. |
| `daily_cap` | Cap diario del agent | Esperar UTC midnight o bajar SKU. Consume de pass vigente **sí** permitido. |
| `per_tx_cap` | Precio SKU > cap por tx | SKU más barato o pack (el pack cuenta como una tx de 9 o 19). |
| `rate_limited` | Techo IP/agent/wallet/SKU | Esperar `retryAfterSec`. Backoff. |
| `circuit_open` | Abuso / 429 repetidos | Esperar `retryAfterSec` (minutos). No martillar. |
| `forbidden` | Grant/pass de otro usuario | Misma identidad que pagó. |
| `bad_request` | SKU desconocido / input | Validar contra `listCatalog`. |

HTTP: `429` + `Retry-After` en discovery/MCP rate-limited. tRPC usa `TOO_MANY_REQUESTS`.

---

## 7. Mejores prácticas para agents

### 7.1 Reintentos

| Situación | Política |
|-----------|----------|
| `rate_limited` / `circuit_open` | Esperar `retryAfterSec`. Jitter. Máximo 3 reintentos. |
| `verify_failed` + tx reciente | Poll 2–5 s, máximo ~30 s. No firmar otra tx. |
| `expired` / `exhausted` / `integrity` / `revoked` | **No** reintentar el mismo pass. |
| `daily_cap` / `per_tx_cap` | No reintentar el mismo SKU el mismo día (salvo que `remainingUsdc` baste). |
| 5xx / red | Backoff exponencial. Idempotencia: el mismo `txSignature` no debe pagarse dos veces. |

### 7.2 Rate limit

Clases (`klass`): `discovery` (120/min) · `entry` (30) · `pack` (40) · `premium` (6).  
Circuit breaker: 8 denegaciones / 60 s → abierto 5 min.  
No paralelizar 20 `deep_report`. Serializa premium.

### 7.3 NFA (obligatorio)

- Toda respuesta del Templo trae `nfa` / `nfaDisclaimer`.
- El agent **no** debe traducir una lectura en “compra X” ni ejecutar trades con el output.
- Si reenvías el análisis a un humano, replica el disclaimer.
- Cripto Nous no es exchange, ni bot de trading, ni grupo de señales.

### 7.4 Presupuesto

1. `temple_budget` al arrancar el loop.
2. Prefiere `session.24h` ($9) si vas a hacer varias lecturas entry/día: techo SKU ≤ $1.00 y spendingCap 12 USDC (hasta $12 de valor catalogado). No lo compres solo por “ahorrar” lecturas de $0.02.
3. No compres `pantheon.deep_report` con un daily cap de 15 si el per-tx cap es 15 y ya gastaste algo: el cap por tx bloquea 15.00 exacto si `perTxCapUsdc` es 15 (cabe); si el cap es menor, no.

### 7.5 Concurrencia

`consume` está serializado **por `passId`** en el proceso. Aun así: no lances 12 consumes paralelos contra un pass de 3 usos y esperes 12 éxitos. El excedente vuelve `exhausted`. Prefiere cola.

### 7.6 Secretos

Nunca envíes private keys al Templo. Solo `txSignature` + `payerWallet`. El vault x402 es address pública.

### 7.7 Reloj

Usa `expiresAtIso` del servidor. Si tu reloj está desfasado, puedes intentar consume de un pass ya expirado (`expired`).

---

## 8. Ejemplo: loop de un agent autónomo

Pseudocódigo estricto (no ejecuta trades):

```ts
async function templeRead(sku: "hermes.pulse" | "poseidon.flow"): Promise<void> {
  const budget = await mcp("temple_budget");
  if (!budget.tab.allowedSkus.includes(sku)) {
    throw typed("allowlist_blocked");
  }

  let passId = loadPassId(); // persistencia del agent
  if (passId) {
    const v = await mcp("temple_validate_pass", { passId, sku });
    if (v.success) {
      const c = await mcp("temple_consume_pass", { passId, sku });
      if (c.success) {
        persistPass(c.pass); // usesRemaining actualizado
        analyze(c); // inteligencia, NFA — no orden
        return;
      }
      if (!c.retryable) passId = null;
    } else if (
      v.code === "expired" ||
      v.code === "exhausted" ||
      v.code === "integrity"
    ) {
      passId = null;
    } else if (v.code === "rate_limited") {
      await sleep(v.retryAfterSec * 1000);
      return templeRead(sku);
    }
  }

  if (budget.tab.remainingUsdc < priceOf(sku)) {
    throw typed("daily_cap");
  }

  const tribute = await mcp("temple_request_tribute", { sku });
  const tx = await wallet.transferUsdcSpl({
    to: tribute.request.recipientVault,
    amount: tribute.request.amountUsdc,
    memo: tribute.request.memo,
    mint: manifest.usdcMint,
  });

  let granted = await mcp("temple_verify", {
    requestId: tribute.request.requestId,
    txSignature: tx.signature,
    payerWallet: tx.payer,
  });
  let attempts = 0;
  while (!granted.success && granted.retryable && attempts < 6) {
    await sleep(3000);
    granted = await mcp("temple_verify", { ... });
    attempts += 1;
  }
  if (!granted.success) throw granted;

  savePassId(granted.pass.passId);
  const c = await mcp("temple_consume_pass", {
    passId: granted.pass.passId,
    sku,
  });
  analyze(c); // NFA
}
```

Variante pack: compra `session.24h` una vez, guarda `passId`, y durante 24 h consume `hermes.pulse` / `poseidon.flow` / `delfos.signal` sin nuevo pago, vigilando `usesRemaining` y `spentUsdc` vs `spendingCapUsdc`.

---

## 9. Límites honestos (no son bugs)

- **Sin dominio público / HTTPS** los índices x402scan/OpenDexter no te listarán. Discovery = URL que tú le pases al agent.
- Rate limit y spending tabs son **in-process**. Varias réplicas no comparten contadores (Redis = iteración ops futura, no deuda oculta).
- Wire HTTP 402 existe en `/x402/resource/{sku}` (Solana live). Facilitators multi-chain = Fase 5 (no live). Pago actual = SPL USDC directo al vault.
- Settlement **live**: Solana / USDC. Roadmap: Base + BNB (skeleton en manifiesto `chainsRoadmap`). ETH L1 diferido (gas). Ver `docs/X402_V2_FASE5_MULTI_RAIL.md`.
- Health es gratis; todo lo demás del catálogo es de pago.

---

## 10. Referencias

| Doc | Contenido |
|-----|-----------|
| `docs/X402_V2_ACCESS_PASS.md` | Política de passes / packs |
| `docs/X402_V2_RECEIPTS.md` | Receipts + audit |
| `docs/X402_V2_ELITE_GUARDS.md` | Rate limit, caps, vaults |
| `docs/X402_V2_FASE3_DISCOVERY.md` | Well-known / MCP |
| `docs/X402_V2_OBSERVABILITY.md` | Logs estructurados internos |
| `docs/X402_LIST_BADGE.md` | Badge x402-list (trust marker) |
| `server/services/x402-v2/catalog.ts` | Precios canónicos |

**Directory listing:** [x402-list · criptonous-market-intelligence](https://x402-list.com/services/criptonous-market-intelligence)

**NFA — Inteligencia de mercado / análisis. No es consejo financiero ni orden de compra/venta.**