Admit only verified agents

npm install tollstile @tollstile/hono @tollstile/web-bot-auth hono @hono/node-server

import { readFileSync } from "node:fs";
import { serve } from "@hono/node-server";
import { Hono } from "hono";
import { tollstile } from "@tollstile/hono";
import { verifiedAgent } from "@tollstile/web-bot-auth";
import { createTollstile, memoryLedger, testRail } from "tollstile";

const AGENT = "https://agent.example";
const DIRECTORY = `${AGENT}/.well-known/http-message-signatures-directory`;

// Local development only: serve the agent's key directory from a file instead of the network.
const localDirectory: typeof fetch = (input, init) =>
  String(input) === DIRECTORY
    ? Promise.resolve(
        new Response(readFileSync("directory.json"), {
          headers: { "content-type": "application/http-message-signatures-directory+json" },
        }),
      )
    : fetch(input, init);

const toll = createTollstile({ rails: [testRail()], ledger: memoryLedger() });

const agentsOnly = toll.price("$0.01", {
  require: [verifiedAgent({ trust: [AGENT], requireNonce: true, fetch: localDirectory })],
});

const app = new Hono();
app.get("/weather", tollstile(agentsOnly), (c) => c.json({ forecast: "clear" }));

serve({ fetch: app.fetch, port: 3000 });

import { writeFileSync } from "node:fs";

const { publicKey, privateKey } = (await crypto.subtle.generateKey({ name: "Ed25519" }, true, ["sign", "verify"])) as CryptoKeyPair;
const { kty, crv, x } = await crypto.subtle.exportKey("jwk", publicKey);

// What https://agent.example/.well-known/http-message-signatures-directory serves.
writeFileSync("directory.json", JSON.stringify({ keys: [{ kty, crv, x }] }, null, 2));
// The agent's private key. Never publish it.
writeFileSync("agent-key.json", JSON.stringify(await crypto.subtle.exportKey("jwk", privateKey)));

import { readFileSync } from "node:fs";

const AGENT = "https://agent.example";
const url = new URL(process.argv[2] ?? "http://localhost:3000/weather");

const privateJwk = JSON.parse(readFileSync("agent-key.json", "utf8")) as JsonWebKey;
const key = await crypto.subtle.importKey("jwk", privateJwk, { name: "Ed25519" }, false, ["sign"]);

// keyid is the RFC 7638 thumbprint: SHA-256 over the public key's required members, in order.
const { crv, kty, x } = privateJwk;
const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify({ crv, kty, x })));
const keyid = Buffer.from(digest).toString("base64url");

const created = Math.floor(Date.now() / 1000);
const params =
  `("@authority" "@method" "@path" "signature-agent";key="sig1")` +
  `;created=${created};expires=${created + 60};keyid="${keyid}";alg="ed25519"` +
  `;nonce="${crypto.randomUUID()}";tag="web-bot-auth"`;

// The signature base: one line per covered component, then the signature parameters.
const base = [
  `"@authority": ${url.host}`,
  `"@method": GET`,
  `"@path": ${url.pathname}`,
  `"signature-agent";key="sig1": "${AGENT}"`,
  `"@signature-params": ${params}`,
].join("\n");
const signature = await crypto.subtle.sign("Ed25519", key, new TextEncoder().encode(base));

const response = await fetch(url, {
  headers: {
    payment: "test",
    "signature-agent": `sig1="${AGENT}"`,
    "signature-input": `sig1=${params}`,
    signature: `sig1=:${Buffer.from(signature).toString("base64")}:`,
  },
});
console.log(response.status, await response.text());

node keys.ts
node server.ts

node agent.ts                                       # 200 {"forecast":"clear"}
curl -i localhost:3000/weather                      # 402: payment comes first
curl -i -H "Payment: test" localhost:3000/weather   # 403: paid, but not signed

HTTP/1.1 403 Forbidden

{"error":{"code":"requirement_failed","retryable":false,"action":"stop","message":"Requirement \"verified-agent\" was not met.","detail":"signature_missing"},
 "resource":"GET /weather","requirement":"verified-agent"}