# x402 & ERC‑8004 - Three‑Phase Integration Plan

A generalized, phased plan to enable x402 payments and ERC‑8004 compatibility across Cortensor, starting with COR Prover and expanding to core inference and agent flows.

### **Objective**

Become agentic AI infrastructure — an agent‑ready network offering one‑of‑a‑kind inference + validation (COR Prover) as first‑class, composable services discoverable via ERC‑8004 and callable via MCP with x402 payments.

### Key Points (TL;DR)

* **Three Phases**
  1. **Phase 1 — COR Prover x402 MVP (ERC‑8004‑ready):** delegated sessions, k‑redundant inference on the same input, time‑gated **commit → reveal** state machine, **PoI** consensus + **v3 LLM eval**, signed attestations, optional on‑chain anchoring.
  2. **Phase 2 — Hardening, Passes & 8004 Expansion:** webhook push, idempotent invoices, access passes/quotas, ops/observability, publish to ERC‑8004 Validation (and optional Reputation) registries by default.
  3. **Phase 3 — Core Inference & Agent Flows:** one‑shot x402 for `/v1/infer` + agent‑bound inference (ERC‑8004 agent bindings, `cnf`/DPoP), reuse the same rails.
* **Built on Cortensor core protocol**: multiple miners run the **same input** under a **time‑gated** commit→reveal state machine; results are aggregated via **PoI/consensus** to mitigate hallucinations and surface anomalies. No core protocol changes required for Phase 1 (uses **delegated sessions**).
* **Router Node → Router Agent (MCP + 8004)**: evolve the existing Web2 RESTful Router Node into a dual‑mode **Router Agent** that exposes both **Inference** and **Validation (COR Prover)** services via HTTP **and** MCP, discoverable as ERC‑8004 agents and payable via x402. Node operators can run/operate these agent roles alongside mining.

***

### Phase 1 — COR Prover x402 MVP (no core changes, ERC‑8004‑ready)

**What ships**

* x402 middleware (pull/JWS first; webhook optional)
* Prover API using **delegated sessions** (service account)
* **k‑redundant** commit→reveal orchestration via Session/SessionQueue
* **PoI** consensus + **v3 LLM evaluation**
* **Attestation** (JWS; optional EIP‑712) + evidence bundle (IPFS/Arweave)
* Minimal accounting (Invoices + Prover Jobs) + Redis single‑use replay cache
* **ERC‑8004**: register COR Prover identity; write **ValidationResponse** (Mode A: off‑chain first, on‑chain anchor)

**API**

* `POST /v1/prover/validate` → 402 challenge (scope bound to `jobHash`) → x402 receipt → 202 `{jobId}`
* `GET /v1/prover/jobs/{jobId}` → state
* `GET /v1/prover/jobs/{jobId}/attestation` → signed JWS/EIP‑712

**x402 challenge (template)**

```
WWW-Authenticate: X402 ver="1"; facilitators="onchain"; amount="0.002"; currency="ETH"; chain_id="42161"; pay_to="0xCOR_TREASURY"; price_version="p1"; invoice="inv_<opaque>"; jti="j_<uuid>"; nonce="n_<rand>"; scope="POST:/v1/prover/validate#job=<H(input,candidate,policy)>"; exp="<ISO8601+60s>"; proof="jws"; callback="https://api.cortensor.dev/x402/webhook"; jwks="<facilitator-jwks>"
```

**Attestation payload (sketch)**

```json
{
  "iss":"cor-prover","sub":"job_abc","aud":"https://api.cortensor.dev",
  "job":{"input_hash":"H(...)","candidate_hash":"H(...)","policy":{"k":5,"eval":"v3"}},
  "session":{"id":"sess_...","tasks":["t1","t2","t3","t4","t5"],"commit_ms":10000,"reveal_ms":10000},
  "poi":{"method":"cluster-median","dispersion":0.13,"anomalies":["m12"]},
  "v3_eval":{"score":0.87,"rubric":["factuality","consistency"]},
  "settlement":{"invoice":"inv_xyz","amount":"0.002","currency":"ETH","tx_hash":"0x..."},
  "iat": 1730088000, "exp": 1730091600
}
```

**Acceptance (Phase 1)**

* 402 challenge w/ correct scope + 60s TTL
* JWS receipt verification + **single‑use** enforcement
* Valid **Attestation** (offline‑verifiable)
* `invoice ↔ sessionId ↔ taskIds` linkage
* End‑to‑end success under target SLA with `k=5` on testnet

***

### Phase 2 — Hardening, Passes & ERC‑8004 Expansion

* **Webhook push** path + idempotent invoice state machine
* **Passes/Entitlements**: `POST /v1/prover/passes` (x402) → issue **Cortensor Access Token** (JWS) with `quota|window|sla_tier` → skip 402 on hot path
* **Observability**: job timelines; miner dispersion histograms; receipt‑verify metrics
* **Refunds**: admin tool; deterministic mapping to revoke/annotate attestations
* **Abuse controls**: per‑buyer rate‑limits; min/max `k`; payload caps; policy sanity checks
* **8004 defaults**: publish ValidationResponse by default; (optional) Reputation writes

***

### Phase 3 — Core Inference & Agent Flows (ERC‑8004)

* **Core one‑shot x402**: `POST /v1/infer` supports 402 + **passes**; server creates **ephemeral sessions** under caller (or OBO via service account)
* **Streaming**: `POST /v1/infer/stream` (scope bound to `streamTaskId`)
* **Agent flows**: `/v1/agents/{agentId}/infer` & `/v1/agents/{agentId}/prover/validate` with **Agent <8004>** + **X402** headers; require `cnf`/DPoP binding and include `agent_id` in scope
* **SessionPaymentStaking** (optional): credit pool after x402; settle via existing SessionPayment

#### MCP Integration (Model Context Protocol)

* **Expose Cortensor as an MCP server** so agent runtimes can discover and call tools without bespoke wiring.
* **Tools (methods & args)**
  * `cortensor.infer(prompt: string, policy?: { k?: number, modelHints?: object, sla?: string }, stream?: boolean)` → returns `jobId` and result (or streams tokens if `stream=true`).
  * `cortensor.prover.validate(input: any, candidate: any, policy?: { k?: number, timeBudgetSec?: number, eval?: "v3" })` → returns `jobId`, later `attestation`.
* **Auth & Payment over MCP**
  * On first call, server emits an **x402 challenge event** (same fields as HTTP 402). Client responds with a **facilitator receipt** (JWS) via MCP `tool/use` metadata.
  * Support **passes** to skip repeated challenges. Bind payment to caller via **`cnf`/DPoP**; include `agent_id` in `scope` for ERC‑8004 agents.
* **Streaming**
  * Use MCP `tool/result` streaming chunks for `infer(stream=true)`; scope binds to `streamTaskId`.
* **Discovery**
  * Advertise tools and schemas in MCP `capabilities`/`tools` manifest; link to `/.well-known/x402.json` for rails/pricing.
* **Lifecycle**
  * Server creates **ephemeral sessions** per call (or reuses when a **pass** is active). OBO supported via service account.
* **Errors & telemetry**
  * Map x402/payment errors to MCP error codes; include `invoice_id` and `requestHash` for audit.

***

#### ERC‑8004 Agent Registration (MCP‑backed Sessions)

* **Two discoverable services** registered as 8004 agents so other agents can find and pay via x402:
  1. **Cortensor Inference Agent** (`agent:cortensor:infer:v1`) — wraps `/v1/agents/{agentId}/infer` and MCP tool `cortensor.infer`; creates **ephemeral sessions** per call (or reuses when a pass is active).
  2. **COR Prover (Validation) Agent** (`agent:cortensor:prover:v1`) — wraps `/v1/agents/{agentId}/prover/validate` and MCP tool `cortensor.prover.validate`; runs **delegated sessions** to execute k‑redundant re‑inference and produce **attestations**.
* **Discovery/Manifests**: publish **Agent Cards** that reference both **HTTP endpoints** and **MCP tools**, with pricing/SLA and x402 rails.
* **Scope & binding**: include `agent_id` in `scope`; require **cnf/DPoP** so receipts are bound to the calling agent. Receipts/passes are accepted over HTTP or MCP.
* **Session semantics**: sessions are **ephemeral** and **bound to (agentId, jobId)**; OBO (on‑behalf‑of) supported via service account. Validation agent writes **ValidationResponse** to the 8004 registry (Mode A now; Mode B later).

**Minimal Agent Card (illustrative)**

```json
{
  "id": "agent:cortensor:infer:v1",
  "capabilities": ["infer"],
  "endpoints": {
    "http": {"infer": "/v1/agents/{agentId}/infer"},
    "mcp": {"tools": ["cortensor.infer"]}
  },
  "payments": {"protocol": "x402", "discovery": "/.well-known/x402.json"},
  "slaTiers": [{"k":1,"latency":"P10S"},{"k":3,"latency":"P25S"},{"k":5,"latency":"P30S"}]
}
```

```json
{
  "id": "agent:cortensor:prover:v1",
  "capabilities": ["prover.validate"],
  "endpoints": {
    "http": {"validate": "/v1/agents/{agentId}/prover/validate"},
    "mcp": {"tools": ["cortensor.prover.validate"]}
  },
  "payments": {"protocol": "x402", "discovery": "/.well-known/x402.json"},
  "attestation": {"formats": ["JWS","EIP-712"], "evidence": ["ipfs","arweave"]}
}
```

#### Router Node → Router Agent (MCP + 8004)

* **Dual‑mode server**: keep today’s REST endpoints and add an **MCP server**; both surfaces emit/accept x402 challenges/receipts.
* **Two services**: (1) **Inference** (ephemeral sessions per call or pass‑backed reuse), (2) **Validation** (delegated sessions running k‑redundant re‑inference + PoI + PoUW + v3 eval to produce attestations).
* **ERC‑8004 identity**: register Router Agent identities for **Inference** and **Validation** (or a multi‑capability single agent). Include `agent_id` in x402 `scope`; require **cnf/DPoP** binding for agent callers.
* **NodeOps packaging**: single Docker image / Helm chart with flags: `--enable-mcp`, `--enable-validation`, `--mcp-port`, `--http-port`, `--agent-id`, `--erc8004-key`, `--x402-discovery-url`, `--service-account-key`. Defaults keep behavior backward‑compatible (REST‑only) until enabled.
* **Security**: DPoP on agent flows; short‑TTL receipts; single‑use with Redis; attestation signer keys managed per node (rotatable), with public JWKS for verification.
* **Migration path**: start by enabling Inference over MCP; add Validation once COR Prover pipeline is stable; optional Mode B (on‑chain requests) later.
* **Observability**: per‑agent metrics (402 rate, job latency, k, dispersion), webhook success, MCP tool usage, and attestation issuance counts.

### Pricing & SLA Matrix (example)

| Tier       |  k | SLA (p50) | What you get                           | Price (ETH) |
| ---------- | -: | --------: | -------------------------------------- | ----------: |
| Cheap‑Fast |  1 |     5–10s | Single run, no eval                    |     0.00006 |
| Balanced   |  3 |    15–25s | PoI consensus, eval on high dispersion |     0.00012 |
| Critical   |  5 |      ≤30s | PoI + eval always, stronger finality   |     0.00020 |

> Price = base + k multiplier + SLA uplift; adjust for testnet/mainnet.

***

### Security & Compliance Notes

* **Replay**: bind `scope` to `jobHash/sessionId/agentId`; enforce **single‑use** via Redis & invoice state
* **Finality**: facilitator guarantee for UX; background confirmation checks
* **Client binding**: support `cnf`/DPoP for agent‑bound calls
* **Privacy**: hash inputs; store raw evidence off‑chain; gate bundle access

***

### Minimal Data Model (sketch)

* **invoices**: `invoice_id, scope_hash, amount, currency, chain_id, pay_to, facilitator, tx_hash, status, exp, used_at, price_version, jti, buyer_wallet`
* **prover\_jobs**: `job_id, invoice_id, job_hash, session_id, task_ids[], k, policy_json, status, dispersion, score, attestation_jws`


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.cortensor.network/technical-architecture/designs-wip/x402-and-erc-8004-three-phase-integration-plan.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.