@profullstack/x402-gateway 0.13.1 → 0.15.0

package/README.md

@@ -83,6 +83,7 @@ export const GET = robotsRoute(gateway, { disallow: ['/login', '/api/'] });
 | `siteUrl` | required | canonical origin, no trailing slash |
 | `coinpay.apiKey` | | a **scoped** CoinPay key (`cp_live_…`, from the business's API Keys tab) with `payments:create`. The legacy business key is refused by CoinPay's x402 routes. |
 | `payTo` | | EVM address that receives the USDC, on Base, Polygon and Ethereum alike |
+| `nano` | off | `{ payTo: 'nano_…', rate }`: also offer XNO on network `nano`, paid straight to that address. `rate` is the price of 1 XNO in `currency` (a number, or a function read per offer); the amount is in raw (10^30 per XNO), rounded up. `xrb_` payees are rewritten to `nano_`. The buyer sends the block first and presents its hash, so a rate that moves between quote and proof refuses a payment already sent: keep it steady. CoinPay refuses every Nano proof unless its `NANO_RPC_URL` points at a Nano node |
 | `priceCents` | `100` | |
 | `passMinutes` | `1440` | a day: the term one price buys |
 | `maxDays` | `30` | the most terms one proof may buy at once |
@@ -111,6 +112,7 @@ export const GET = robotsRoute(gateway, { disallow: ['/login', '/api/'] });
 | `denyCidrs` | `[]` | IPv4 ranges answered with a tiny `403` before anything else. For a VPS fleet that spoofs a browser: hosting ranges serve no readers. |
 | `chargeSpoofedBrowsers` | `false` | charge a request that claims `Chrome/…` but sends no `Sec-Fetch-Mode`. Every Chromium since 76, headless included, sends it on every request and no script or extension can remove it, so its absence means an HTTP client with a copied string. Firefox and Safari are not judged. |
 | `exempt` | | `(request) => boolean`, never charged: e.g. a request carrying your signed-in cookie |
+| `appPaths` | `APP_PATHS` | extra paths never charged, added to the default sign-in, account, checkout, pay and webhook paths (`/login`, `/signup`, `/oauth`, `/dashboard`, `/checkout`, `/pay`, `/webhooks`, `/api/auth`, `/api/health`, ...; see `APP_PATHS`). Matched by whole segment. An app whose whole `/api/` is credentialed adds `'/api'`. `false` charges them like any page |
 | `powerKeys` | Profullstack's | Power Keys honoured as a pass, kid to public key. `false` switches it off. See below. |
 | `revokedKeys` | | Power Key subjects no longer honoured |
 
@@ -207,6 +209,8 @@ The sales page shows a **Buy a day pass** form (email, days) whenever CoinPay se
 
 USDC on Base, Polygon and Ethereum, and nothing else on purpose: CoinPay's v2 settle broadcasts EIP-3009 `transferWithAuthorization` only on chains 1, 137 and 8453, and USDC is the only EIP-3009 dollar token there (USDT has none). An offer for anything else would verify and never settle. Every other coin, and PayPal, is the checkout button's job.
 
+The exception, opt-in, is XNO with `nano` set. CoinPay settles network `nano` without a relayer: the buyer publishes a send block to `nano.payTo`, and CoinPay's verify and settle ask a Nano node that the block is a confirmed send of at least the quoted raw amount to that address. The block hash is the replay key and the pass's `ref`. CoinPay needs `NANO_RPC_URL` for this; without it every Nano proof is refused.
+
 ## Who is on which list
 
 `TRAINING_AGENTS` is the documented corpus-crawl token of each operator; `RETRIEVAL_AGENTS` the search half of the same pairs: GPTBot / OAI-SearchBot, ClaudeBot / Claude-SearchBot, meta-externalagent / Meta-ExternalFetcher, Applebot-Extended / Applebot. Google-Extended stays welcome because Google documents it as also gating Gemini app grounding. Matching is a substring of the user agent, which identifies a self-declared crawler and nothing more: a crawler wearing a browser's user agent walks past this, and that one needs blocking at the edge.

package/index.d.ts

@@ -74,6 +74,13 @@ export interface GatewayOptions {
   coinpay?: { apiKey?: string; baseUrl?: string };
   /** EVM address that receives the USDC. */
   payTo?: string;
+  /**
+   * Opt-in XNO on Nano: a `nano_` (or legacy `xrb_`) payee and the price of
+   * 1 XNO in `currency`, as a number or a function read per offer. Without a
+   * valid payee and a positive rate the offer is USDC only. CoinPay refuses
+   * Nano proofs unless its NANO_RPC_URL is set.
+   */
+  nano?: { payTo: string; rate: number | (() => number) };
   /** Default 100 ($1). */
   priceCents?: number;
   currency?: string;
@@ -114,6 +121,8 @@ export interface GatewayOptions {
   welcome?: WelcomeCrawler[] | false;
   /** Requests never charged, e.g. ones carrying a signed-in cookie. */
   exempt?: (request: Request) => boolean;
+  /** Extra sign-in, account and payment paths never charged, appended to APP_PATHS and matched by whole segment. `false` charges APP_PATHS like any page. */
+  appPaths?: string[] | false;
   /** Pass signing secret. Defaults to the CoinPay key. */
   secret?: string;
   page?: (ctx: PageContext) => string;
@@ -192,7 +201,7 @@ export interface AcceptEntry {
   description: string;
   mimeType: string;
   maxTimeoutSeconds: number;
-  extra: { name: string; version: string };
+  extra: { name: string; version: string } | { decimals: number };
 }
 
 export interface Offer {
@@ -274,6 +283,10 @@ export function wantsHtml(accept?: string | null): boolean;
 export const TRAINING_AGENTS: string[];
 export const SCRAPER_AGENTS: string[];
 export const HEADLESS_AGENTS: string[];
+/** Sign-in, account, payment and webhook paths the gateway never charges. */
+export const APP_PATHS: readonly string[];
+/** Whether `path` is one of `paths` (default APP_PATHS) or below it, by whole segment. */
+export function isAppPath(path: string, paths?: readonly string[]): boolean;
 export const AI_INDEX_AGENTS: string[];
 export function challengeToken(secret: string, ip: string, day?: number): Promise<string>;
 export function passedChallenge(request: Request, options: { secret: string; cookie: string; ip: string; work?: number; css?: boolean; now?: number }): Promise<boolean>;
@@ -313,7 +326,11 @@ export function readPass(token: string, args: { secret: string; now?: number }):
 
 export const METHODS: Array<{ key: string; network: string; asset: string; label: string }>;
 export const X402_METHODS: typeof METHODS;
-export function buildOffer(args: { payTo: string; priceCents: number; resource: string; description?: string; maxTimeoutSeconds?: number; methods?: typeof METHODS }): Offer;
+export function buildOffer(args: { payTo: string; priceCents: number; resource: string; description?: string; maxTimeoutSeconds?: number; methods?: typeof METHODS; nano?: { payTo: string; amount: string } | null }): Offer;
+/** A Nano payee in canonical `nano_` form, or null. */
+export function nanoPayee(address: unknown): string | null;
+/** A price in raw XNO (10^30 per XNO), rounded up, at `rate` per XNO; null if either is not positive. */
+export function xnoRaw(priceCents: number, rate: number): string | null;
 export function decodePayment(header: string | null | undefined): Record<string, unknown> | null;
 export function decodeHeader(header: string | null | undefined): Record<string, unknown> | null;
 export function encodeHeader(value: unknown): string;
@@ -322,14 +339,14 @@ export function paymentResponseHeader(args: { transaction?: string | null; netwo
 export function renderNotice(ctx: { siteName: string; siteUrl: string; buyUrl: string; title: string; body: string }): string;
 export function renderPassPage(ctx: { siteName: string; siteUrl: string; buyUrl: string; token: string; expiresAt: string; days: number; header: string; cookie: string; email?: string | null }): string;
 export function sessionIdFromWebhook(body: unknown): string | null;
-export function expectedFor(payment: unknown, offer: Offer): { amount: string; resource: string; payTo: string; asset: string } | null;
+export function expectedFor(payment: unknown, offer: Offer): { amount: string; resource: string; payTo: string; asset?: string } | null;
 /** The value a proof authorizes, in the token's smallest unit, or null. */
 export function paidValueOf(payment: unknown): bigint | null;
 /** How many terms `value` buys at `unit` per term: a whole number in [1, maxDays], or 0. */
 export function daysPaid(value: bigint | null, unit: string | number | bigint, maxDays: number): number;
 export function verifyAndSettle(
   payment: unknown,
-  expected: { amount: string; resource: string; payTo: string; asset: string },
+  expected: { amount: string; resource: string; payTo: string; asset?: string },
   coinpay: { apiKey: string; baseUrl: string; fetch?: typeof fetch; metadata?: Record<string, unknown> | null },
 ): Promise<{ ok: true; payer: string | null; ref: string | null; txHash: string | null; network: string | null } | { ok: false; reason: string; replay: boolean }>;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profullstack/x402-gateway",
-  "version": "0.13.1",
+  "version": "0.15.0",
   "type": "module",
   "description": "Sell crawl access to AI training crawlers by the day over x402, settled by CoinPay. One middleware: 402 with an offer, a sales page with CLI instructions, signed passes, Profullstack Power Keys honoured as a pass, and a robots.txt that keeps search crawlers welcome.",
   "keywords": [

package/src/index.js

@@ -12,12 +12,14 @@ import {
   decodePayment,
   expectedFor,
   METHODS,
+  nanoPayee,
   nonceOf,
   paymentRequiredHeader,
   paymentResponseHeader,
   settleAgain,
   validBeforeOf,
   verifyAndSettle,
+  xnoRaw,
 } from './x402.js';
 
 export {
@@ -62,13 +64,78 @@ export {
   encodeHeader,
   expectedFor,
   METHODS,
+  nanoPayee,
   paymentRequiredHeader,
   paymentResponseHeader,
   verifyAndSettle,
+  xnoRaw,
 } from './x402.js';
 export { memoryQuotaStore, normaliseQuota, quotaHeaders, spend } from './quota.js';
 export { isPowerKey, keyFrom, PROFULLSTACK_KEYS, verifyKey } from '@profullstack/keys';
 
+/**
+ * Where people and their agents sign in, pay and run an account. Never charged.
+ *
+ * The gateway sells reading, and none of these is reading: a 402 on /login is
+ * not an offer anybody can take, it is a locked door. Since 0.8 a stale or
+ * headless browser string is charged on every path, and every path included
+ * these, so an agent whose OAuth token lapsed could not sign back in, a person
+ * on a two-year-old Chrome could not reach checkout, and a processor's webhook
+ * wearing an old user agent was answered with a price. Each is matched as a
+ * whole path segment: `/pay` covers `/pay/abc` and not `/payouts-explained`.
+ * Sites add their own with `appPaths` (they are appended) and an app whose
+ * whole `/api/` is credentialed adds `/api`.
+ */
+export const APP_PATHS = Object.freeze([
+  '/login',
+  '/logout',
+  '/signin',
+  '/sign-in',
+  '/signout',
+  '/sign-out',
+  '/signup',
+  '/sign-up',
+  '/register',
+  '/auth',
+  '/oauth',
+  '/sso',
+  '/callback',
+  '/forgot-password',
+  '/reset-password',
+  '/verify',
+  '/verify-email',
+  '/dashboard',
+  '/account',
+  '/settings',
+  '/admin',
+  '/onboarding',
+  '/checkout',
+  '/pay',
+  '/billing',
+  '/webhook',
+  '/webhooks',
+  '/api/auth',
+  '/api/oauth',
+  '/api/health',
+  '/api/webhook',
+  '/api/webhooks',
+  '/api/checkout',
+]);
+
+/**
+ * Whether `path` is one of `paths` or below it, matched by whole segments.
+ *
+ * @param {string} path
+ * @param {readonly string[]} [paths=APP_PATHS]
+ * @returns {boolean}
+ */
+export function isAppPath(path, paths = APP_PATHS) {
+  return paths.some((p) => {
+    const base = p.replace(/\/+$/, '');
+    return path === base || path.startsWith(`${base}/`);
+  });
+}
+
 /**
  * A gateway that sells crawl access to training crawlers, by the day, over x402.
  *
@@ -90,6 +157,7 @@ export { isPowerKey, keyFrom, PROFULLSTACK_KEYS, verifyKey } from '@profullstack
  * @param {string} [options.siteName]              for the page; defaults to the hostname
  * @param {{apiKey: string, baseUrl?: string}} [options.coinpay]  a SCOPED CoinPay key (cp_live_…) with payments:create
  * @param {string} [options.payTo]                 EVM address that receives the USDC
+ * @param {{payTo: string, rate: number|(() => number)}} [options.nano]  opt-in XNO on Nano: a nano_ (or xrb_) payee and the price of 1 XNO in `currency`; CoinPay must have NANO_RPC_URL set
  * @param {number} [options.priceCents=100]
  * @param {string} [options.currency='USD']
  * @param {number} [options.passMinutes=1440]          a day: the term one payment buys
@@ -109,6 +177,7 @@ export { isPowerKey, keyFrom, PROFULLSTACK_KEYS, verifyKey } from '@profullstack
  * @param {{paths: string[], cookie?: string, work?: number|boolean, css?: boolean, cssPath?: string, when?: (request: Request, url: URL) => boolean}|false} [options.challenge]  requests to these paths (and, with `when`, only those it accepts, e.g. faceted URLs) must run a one-line script (cookie + reload) first; with `work` (bits, `true` = 16) the script must also solve a SHA-256 proof of work, so a swarm that rotates its address every page pays it on every page; with `css` the page links a per-address stylesheet (at `cssPath`, default `/__pf/c/`) whose fetch sets a second cookie, so a scraper that blocks stylesheets never passes; off by default
  * @param {{token: string, cidrs: string[]}[]|false} [options.welcome]  search crawlers never metered when name and address agree; default WELCOME_CRAWLERS
  * @param {(request: Request) => boolean} [options.exempt]  requests never charged, e.g. ones carrying a signed-in cookie
+ * @param {string[]|false} [options.appPaths]       extra sign-in, account and payment paths never charged, added to APP_PATHS; `false` charges them like any page
  * @param {string} [options.secret]                pass signing secret; defaults to the CoinPay key
  * @param {Record<string,string>|false} [options.powerKeys]  kid -> public key of the Power Keys honoured as a pass; defaults to Profullstack's, `false` switches it off
  * @param {Iterable<string>} [options.revokedKeys]  Power Key subjects no longer honoured
@@ -215,6 +284,23 @@ export function createGateway(options = {}) {
     return Math.min(n, o.maxDays);
   };
 
+  /**
+   * The XNO entry's payee and raw amount for `days` terms, or null. `days`
+   * times one term's raw, never the raw of `days` times the price, so a proof
+   * for N terms is an exact multiple of the per-term amount, as for USDC.
+   */
+  const nanoFor = (days) => {
+    if (!o.nano) return null;
+    let rate;
+    try {
+      rate = typeof o.nano.rate === 'function' ? o.nano.rate() : o.nano.rate;
+    } catch {
+      return null;
+    }
+    const raw = xnoRaw(o.priceCents, rate);
+    return raw ? { payTo: o.nano.payTo, amount: String(BigInt(raw) * BigInt(days)) } : null;
+  };
+
   /** The offer for `days` terms: the same entries, `days` times the price. */
   const offer = (days = 1) =>
     enabled
@@ -223,6 +309,7 @@ export function createGateway(options = {}) {
           priceCents: o.priceCents * days,
           resource: buyUrl,
           description: `${days * o.passMinutes} minutes of crawl access to ${o.siteUrl}${days > 1 ? ` (${days} × ${o.passMinutes})` : ''}`,
+          nano: nanoFor(days),
         })
       : { x402Version: 2, accepts: [] };
 
@@ -803,6 +890,8 @@ export function createGateway(options = {}) {
       return stylesheetResponse(request, { secret, cookie: o.challenge.cookie, ip: clientIp(request), cssPath: o.challenge.cssPath });
     }
     if (o.exempt && o.exempt(request)) return null;
+    // Signing in, paying and running an account are never sold. See APP_PATHS.
+    if (o.appPaths && isAppPath(path, o.appPaths)) return null;
 
     /*
      * A valid pass is checked before anything else that could refuse, because
@@ -957,7 +1046,8 @@ export const wantsHtml = (accept = '') => String(accept ?? '').toLowerCase().inc
 
 /** The value a proof authorizes, in the token's smallest unit, or null. */
 export function paidValueOf(payment) {
-  const raw = payment?.payload?.authorization?.value;
+  // A Nano proof states its amount in raw; CoinPay then holds the block to the offer.
+  const raw = payment?.payload?.authorization?.value ?? (payment?.network === 'nano' ? payment?.payload?.amount : undefined);
   if (raw === undefined || raw === null || raw === '') return null;
   try {
     const value = BigInt(raw);
@@ -1007,6 +1097,7 @@ function normalise(options) {
       baseUrl: (options.coinpay?.baseUrl ?? 'https://coinpayportal.com').replace(/\/+$/, ''),
     },
     payTo: options.payTo ?? '',
+    nano: nanoPayee(options.nano?.payTo) ? { payTo: nanoPayee(options.nano.payTo), rate: options.nano.rate } : null,
     priceCents: Number.isFinite(options.priceCents) ? options.priceCents : 100,
     currency: options.currency ?? 'USD',
     passMinutes: Number.isFinite(options.passMinutes) && options.passMinutes > 0 ? options.passMinutes : 1440,
@@ -1019,6 +1110,7 @@ function normalise(options) {
     chargeStaleBrowsers: options.chargeStaleBrowsers !== false,
     chargeImpostors: options.chargeImpostors !== false,
     exempt: options.exempt ?? null,
+    appPaths: options.appPaths === false ? null : [...APP_PATHS, ...(options.appPaths ?? [])],
     training,
     scrapers,
     headless,

package/src/verify-badge.js

@@ -0,0 +1,61 @@
+/**
+ * x402 endpoint verification badge — a well-known metadata endpoint that
+ * lets external indexers (like nullclear.dev) verify that an x402 gateway
+ * is live, what methods it accepts, and what its settlement flow looks like.
+ *
+ * GET /.well-known/x402-verify returns a JSON object with:
+ * - version: the x402 protocol version (1 or 2)
+ * - methods: the payment methods the gateway accepts
+ * - settleFlow: how settlement works (verify-then-settle)
+ * - lastChecked: ISO timestamp of the last successful settlement
+ *
+ * This is read-only metadata — no secrets, no keys, no payment logic.
+ * Indexers can poll it to confirm the endpoint is live and schema-valid.
+ */
+
+/**
+ * Build the verification badge response for a given x402 gateway configuration.
+ *
+ * @param {object} opts - Gateway configuration
+ * @param {number} opts.x402Version - 1 or 2
+ * @param {Array} opts.methods - The METHODS array from x402.js
+ * @param {string} [opts.payee] - The payee address (optional, for transparency)
+ * @returns {object} The badge metadata
+ */
+export function buildVerificationBadge({ x402Version = 2, methods = [], payee } = {}) {
+  return {
+    spec: 'x402-verify-badge/v1',
+    version: x402Version,
+    methods: methods.map((m) => ({
+      key: m.key,
+      network: m.network,
+      asset: m.asset,
+      label: m.label,
+    })),
+    settleFlow: 'verify-then-settle',
+    settleProvider: 'CoinPay',
+    payee: payee || undefined,
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Hono handler for GET /.well-known/x402-verify.
+ *
+ * Returns the badge as JSON with appropriate cache headers. Indexers should
+ * cache for 5 minutes; the badge is cheap to compute but there's no reason
+ * to hit the gateway on every poll.
+ *
+ * @param {object} badge - The badge object from buildVerificationBadge
+ * @returns {Response} JSON response with cache headers
+ */
+export function verificationBadgeHandler(badge) {
+  return new Response(JSON.stringify(badge, null, 2), {
+    status: 200,
+    headers: {
+      'content-type': 'application/json; charset=utf-8',
+      'cache-control': 'public, max-age=300',
+      'access-control-allow-origin': '*',
+    },
+  });
+}

package/src/x402.js

@@ -34,7 +34,9 @@
  * exactly 1, 137 and 8453, and USDC is the only EIP-3009 dollar token on them
  * (USDT has no EIP-3009). Advertising anything else would quote a payment
  * that verifies and then never settles. Buyers who want another coin, or
- * PayPal, use the hosted checkout on the sales page instead.
+ * PayPal, use the hosted checkout on the sales page instead. The one
+ * exception is XNO on Nano, which CoinPay settles by a node lookup rather
+ * than a relayer, and which `buildOffer` adds only when given a Nano payee.
  */
 export const METHODS = [
   {
@@ -60,6 +62,37 @@ export const METHODS = [
 const DECIMALS = 6;
 const DOMAIN = { name: 'USD Coin', version: '2' };
 
+/**
+ * XNO on Nano, opt-in: CoinPay verifies and settles network `nano` by asking a
+ * Nano node whether the proof's block is a confirmed send of at least the
+ * asking price to `payTo`. Nothing is signed or broadcast, so the buyer sends
+ * the block first and presents its hash. Amounts are in raw, 10^30 per XNO.
+ */
+const NANO_ADDRESS = /^(nano|xrb)_[13][13456789abcdefghijkmnopqrstuwxyz]{59}$/;
+
+/** A Nano payee in canonical `nano_` form, or null if it is not one. */
+export function nanoPayee(address) {
+  const a = String(address ?? '').trim().toLowerCase();
+  if (!NANO_ADDRESS.test(a)) return null;
+  return a.startsWith('xrb_') ? `nano_${a.slice(4)}` : a;
+}
+
+/**
+ * A price in raw XNO, rounded UP, at `rate` units of the price's currency per
+ * XNO. BigInt throughout: 10^30 is far past what a float holds exactly, and
+ * String() of a number that large is exponent notation no verifier parses.
+ * The rate is read to 10^-9 and the price to 10^-6 of a cent. Null if either
+ * is not a positive number.
+ */
+export function xnoRaw(priceCents, rate) {
+  const cents = BigInt(Math.round(Number(priceCents) * 1e6));
+  const per = BigInt(Number.isFinite(Number(rate)) ? Math.round(Number(rate) * 1e9) : 0);
+  if (cents <= 0n || per <= 0n) return null;
+  // raw = (cents / 100) / rate * 10^30 = (cents*1e6) * 10^31 / (rate*1e9)
+  const num = cents * 10n ** 31n;
+  return String((num + per - 1n) / per);
+}
+
 /**
  * A v2 402 body.
  *
@@ -74,9 +107,32 @@ export function buildOffer({
   description = 'Payment required',
   maxTimeoutSeconds = 300,
   methods = METHODS,
+  nano = null,
 }) {
   if (!payTo) throw new Error('an offer needs a payTo address');
   const amount = String(Math.ceil((Number(priceCents) / 100) * 10 ** DECIMALS));
+  /*
+   * XNO goes last, and only with a real Nano payee and a raw amount: without
+   * both the offer is exactly the USDC one.
+   */
+  const xnoTo = nanoPayee(nano?.payTo);
+  const xno =
+    xnoTo && /^[1-9]\d*$/.test(String(nano.amount ?? ''))
+      ? [
+          {
+            scheme: 'exact',
+            network: 'nano',
+            amount: String(nano.amount),
+            asset: 'XNO',
+            payTo: xnoTo,
+            resource,
+            description,
+            mimeType: 'application/json',
+            maxTimeoutSeconds,
+            extra: { decimals: 30 },
+          },
+        ]
+      : [];
   return {
     x402Version: 2,
     accepts: methods.map((m) => ({
@@ -90,7 +146,7 @@ export function buildOffer({
       mimeType: 'application/json',
       maxTimeoutSeconds,
       extra: { ...DOMAIN },
-    })),
+    })).concat(xno),
   };
 }
 
@@ -138,6 +194,22 @@ export function decodePayment(header) {
     if (!parsed.scheme && chosen.scheme) parsed.scheme = chosen.scheme;
     if (parsed.x402Version === undefined) parsed.x402Version = 2;
   }
+  /*
+   * A Nano proof is a block hash, not an EIP-3009 authorization, and CoinPay
+   * reads it on its v1 path: `x402Version` must not be 2, and `network`,
+   * `scheme`, `to`, `amount` and `blockHash` are read from the payload. Lifted
+   * there from wherever this payer put them.
+   */
+  const network = String(parsed.network ?? parsed.payload?.network ?? '').toLowerCase();
+  if (network === 'nano') {
+    const payload = { ...(parsed.payload && typeof parsed.payload === 'object' ? parsed.payload : {}) };
+    payload.network = 'nano';
+    payload.scheme = payload.scheme || parsed.scheme || 'exact';
+    if (!payload.blockHash && parsed.blockHash) payload.blockHash = parsed.blockHash;
+    if (!payload.to && chosen?.payTo) payload.to = chosen.payTo;
+    if (payload.amount === undefined && chosen?.amount) payload.amount = String(chosen.amount);
+    return { ...parsed, x402Version: 1, scheme: payload.scheme, network: 'nano', payload };
+  }
   return parsed;
 }
 
@@ -190,14 +262,24 @@ export function expectedFor(payment, offer) {
   const network = String(payment?.network ?? '').toLowerCase();
   const entry = (offer?.accepts ?? []).find((a) => a.network.toLowerCase() === network);
   if (!entry) return null;
+  /*
+   * XNO is Nano's native coin, which CoinPay's v1 check accepts only with no
+   * asset named on either side, or the same one named on both. The block is
+   * what proves the payment either way.
+   */
+  if (network === 'nano') {
+    const named = payment?.payload?.asset;
+    return { amount: entry.amount, resource: entry.resource, payTo: entry.payTo, ...(named ? { asset: entry.asset } : {}) };
+  }
   return { amount: entry.amount, resource: entry.resource, payTo: entry.payTo, asset: entry.asset };
 }
 
-/** The single-use nonce, which is what CoinPay keys replay detection on. */
-export const nonceOf = (payment) => payment?.payload?.authorization?.nonce ?? null;
+/** The single-use nonce, which is what CoinPay keys replay detection on: a Nano proof's is its block hash. */
+export const nonceOf = (payment) => payment?.payload?.authorization?.nonce ?? payment?.payload?.blockHash ?? null;
 
-/** When the payer's signature stops being valid, as a unix timestamp in seconds. */
+/** When the payer's signature stops being valid, as a unix timestamp in seconds. Null for Nano, which signs nothing with a deadline. */
 export const validBeforeOf = (payment) => {
+  if (String(payment?.network ?? '').toLowerCase() === 'nano') return null;
   const v = Number(payment?.payload?.authorization?.validBefore);
   return Number.isFinite(v) && v > 0 ? v : null;
 };
@@ -228,6 +310,14 @@ export async function verifyAndSettle(payment, expected, { apiKey, baseUrl, fetc
     return { status: res.status, json };
   };
 
+  /*
+   * A block cannot name the resource it bought, so for Nano the gateway names
+   * it: CoinPay compares `payload.resource` with `expected.resource` before it
+   * asks the node about the block.
+   */
+  if (String(payment?.network ?? '').toLowerCase() === 'nano' && payment.payload && !payment.payload.resource) {
+    payment = { ...payment, payload: { ...payment.payload, resource: expected.resource } };
+  }
   const v = await call('/api/x402/verify', { payment, expected });
   if (!v.json?.valid) {
     const reason = String(v.json?.error ?? v.json?.reason ?? `verify failed (${v.status})`);