Quick Start (x402 Server)

What You Get

• ✅ Automatic Registration - Facilitator registers your agent on-chain using EIP-7702
• ✅ Onchain Identity - Your agent gets a unique ID in the ERC-8004 registry
• ✅ Feedback System - Enable authenticated client evaluations
• ✅ No Extra Requests - Registration happens as part of payment settlement

Network Information

app.use(
  paymentMiddleware(
    {
      "/weather": {
        accepts: {
          payTo,
          scheme: "exact",
          price: "$0.001",
          network: "eip155:8453",
        },
        extensions: {
          "erc-8004": {
            registerAuth: registerAuth,        // (required) EIP-7702 authorization
            tokenURI: "https://...",           // (required) metadata URI
            metadata: [{ key: "name", ... }],  // (required) onchain data
            feedbackAuthEndpoint: "/sign",     // (optional) feedback endpoint
            feedbackEnabled: true,             // (optional) enable feedback system
          },
        },
      },
    },
    service,
  ),
);

# OpenMid facilitator URL
FACILITATOR_URL=https://facilitator.openmid.xyz

# Your agent's address (receives payments)
ADDRESS=0x...

# Your agent's private key (for signing)
AGENT_PRIVATE_KEY=0x...

# ERC-8004 delegation contract (Base Sepolia)
DELEGATE_CONTRACT_ADDRESS=0xFdc90fCC6929a2f42a9D714bD10520eEE98bD378

import { createWalletClient, http, type Address } from "viem";
import { baseSepolia } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

async function generateSerializedRegistrationAuthorization(
  delegateContractAddress: Address,
  agentPrivateKey: `0x${string}`,
  chainId: number,
) {
  const agentAccount = privateKeyToAccount(agentPrivateKey);

  const walletClient = createWalletClient({
    account: agentAccount,
    chain: baseSepolia,
    transport: http(),
  });

  const authorization = await walletClient.signAuthorization({
    account: agentAccount,
    contractAddress: delegateContractAddress,
    chainId,
  });

  // Serialize for JSON transmission
  return {
    chainId: authorization.chainId.toString(),
    address: authorization.address,
    nonce: authorization.nonce.toString(),
    yParity: authorization.yParity,
    r: authorization.r,
    s: authorization.s,
  };
}

import express from "express";
import { paymentMiddleware } from "@x402/express";
import { HTTPFacilitatorClient, x402ResourceServer } from "@x402/core/server";
import { registerExactEvmScheme } from "@x402/evm/exact/server";

const app = express();
app.use(express.json());

const facilitatorUrl = process.env.FACILITATOR_URL;
const payTo = process.env.ADDRESS as `0x${string}`;
const agentPrivateKey = process.env.AGENT_PRIVATE_KEY as `0x${string}`;
const delegateContractAddress = process.env.DELEGATE_CONTRACT_ADDRESS as `0x${string}`;

// Initialize OpenMid facilitator client
const facilitatorClient = new HTTPFacilitatorClient({ url: facilitatorUrl });
const service = new x402ResourceServer(facilitatorClient);
registerExactEvmScheme(service);

// Generate the EIP-7702 authorization
const registerAuth = await generateSerializedRegistrationAuthorization(
  delegateContractAddress,
  agentPrivateKey,
  84532, // Base Sepolia chain ID for ERC-8004
);

// Configure payment middleware with ERC-8004 extension
app.use(
  paymentMiddleware(
    {
      "/weather": {
        accepts: {
          payTo,
          scheme: "exact",
          price: "$0.001",
          network: "eip155:8453", // Base Mainnet for payments
        },
        extensions: {
          "erc-8004": {
            registerAuth: registerAuth,
            tokenURI: "https://example.com/tokenURI",
            metadata: [
              { key: "name", value: "Weather Agent" },
              { key: "description", value: "Provides weather data" }
            ],
            feedbackAuthEndpoint: "/signFeedbackAuth",
            feedbackEnabled: true,
          },
        },
      },
    },
    service,
  ),
);

app.get("/weather", (req, res) => {
  res.send({
    report: {
      weather: "sunny",
      temperature: 70,
    },
  });
});

app.post("/signFeedbackAuth", async (req, res) => {
  try {
    const { hash } = req.body;

    if (!hash) {
      return res.status(400).json({
        success: false,
        error: "Missing required field: hash",
      });
    }

    const normalizedHash = hash.startsWith("0x") ? hash : `0x${hash}`;
    const agentAccount = privateKeyToAccount(agentPrivateKey);
    const signature = await agentAccount.sign({ hash: normalizedHash });

    res.json({
      success: true,
      signature,
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message,
    });
  }
});

const PORT = 4021;

app.listen(PORT, () => {
  console.log(`Server listening at http://localhost:${PORT}`);
});

# Query your agent ID
curl "https://facilitator.openmid.xyz/agent?address=0xYourAgentAddress"

# Response if registered:
{
  "success": true,
  "address": "0xyouragentaddress",
  "agentId": "1842"
}

# Response if not registered yet:
{
  "success": false,
  "error": "Agent not found for address: 0x..."
}

# Request without payment
curl http://localhost:4021/weather

# Response: 402 Payment Required
{
  "error": "X-PAYMENT header is required",
  "paymentRequirements": {
    "scheme": "exact",
    "network": "eip155:8453",
    "price": "1000",
    "payTo": "0x...",
    ...
  }
}