diff --git a/migrations/0007_zaps.sql b/migrations/0007_zaps.sql
new file mode 100644
index 0000000..3929e30
--- /dev/null
+++ b/migrations/0007_zaps.sql
@@ -0,0 +1,34 @@
+-- Migration number: 0007    zaps
+-- NIP-57 zap receipts (#12 v1): server-side aggregation of kind 9735
+-- receipts referencing claimed authors' posts, so blog pages can render
+-- "⚡ N sats · M zaps" with zero client JS.
+
+-- One row per validated receipt, deduped by the receipt event id. `address`
+-- is the NIP-33 a-coordinate of the zapped post (30023:<pubkey>:<d_tag>).
+CREATE TABLE zaps (
+  receipt_id TEXT PRIMARY KEY,
+  address TEXT NOT NULL,
+  author_pubkey TEXT NOT NULL,
+  sender_pubkey TEXT,
+  amount_msat INTEGER NOT NULL,
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX idx_zaps_address ON zaps(address);
+
+-- Materialized per-post rollup so the render path (post page, discover,
+-- search) is a single PK lookup / cheap LEFT JOIN, never a SUM over zaps.
+-- Rebuilt idempotently per address after each ingest batch.
+CREATE TABLE zap_totals (
+  address TEXT PRIMARY KEY,
+  msat_total INTEGER NOT NULL,
+  zap_count INTEGER NOT NULL
+);
+
+-- Cache of LNURL-pay `nostrPubkey` lookups, keyed by the exact lud16 string
+-- (receipt validation binds receipts to the author's wallet key; the
+-- .well-known fetch must not run per receipt or per request).
+CREATE TABLE lnurl_cache (
+  lud16 TEXT PRIMARY KEY,
+  nostr_pubkey TEXT,
+  checked_at INTEGER NOT NULL
+);
diff --git a/src/cron/refresh.ts b/src/cron/refresh.ts
index 53281c8..36f28d7 100644
--- a/src/cron/refresh.ts
+++ b/src/cron/refresh.ts
@@ -19,6 +19,7 @@ import { readBlogSettings, type User } from "../services/users";
 import { fetchEvents } from "../nostr/relay";
 import { bumpGen, mirrorEvent } from "../services/mirror";
 import { storedEventIds } from "../services/events";
+import { refreshZapsForUser } from "../services/zaps";
 import type { NostrEvent } from "../nostr/event";
 import { isSelfRelayHost } from "../relay/url";
 
@@ -244,5 +245,12 @@ export async function runRefresh(
       // One user's relay trouble must not sink the whole run.
       console.error(`refresh failed for ${user.pubkey}:`, err);
     }
+    // Zap receipt pass (#12): independent try — a broken LNURL endpoint or
+    // relay must not cost the user their post sync (or vice versa).
+    try {
+      await refreshZapsForUser(env, relays, user);
+    } catch (err) {
+      console.error(`zap refresh failed for ${user.pubkey}:`, err);
+    }
   }
 }
diff --git a/src/routes/main.ts b/src/routes/main.ts
index 33cbc5d..96aa47e 100644
--- a/src/routes/main.ts
+++ b/src/routes/main.ts
@@ -35,6 +35,7 @@ import { CACHE_STATUS_HEADER, defaultCache } from "../middleware/cache";
 import type { BlogProfile } from "../views/tenant/layout";
 import { BlogHome } from "../views/tenant/home";
 import { PostPage } from "../views/tenant/post";
+import { postZap } from "./tenant";
 import { NotFoundPage } from "../views/tenant/not-found";
 import { rssFeed, atomFeed } from "../views/tenant/xml";
 
@@ -495,7 +496,12 @@ async function npubProfile(
 ): Promise<BlogProfile | null> {
   const row = await getProfileRow(env, pubkey);
   return row
-    ? { name: row.name, picture: row.picture, about: row.about }
+    ? {
+        name: row.name,
+        picture: row.picture,
+        about: row.about,
+        lud16: row.lud16,
+      }
     : null;
 }
 
@@ -614,6 +620,7 @@ mainRoutes.get(`${NPUB_PARAM}/:slug`, async (c) => {
   if (bodyHtml === null) return notFoundNpub(c);
 
   const profile = await npubProfile(c.env, r.pubkey);
+  const zap = await postZap(c.env, r.pubkey, slug, profile?.lud16);
   return c.html(
     PostPage({
       handle: displayNpub(r.npub),
@@ -623,6 +630,7 @@ mainRoutes.get(`${NPUB_PARAM}/:slug`, async (c) => {
       themeCss: "",
       mainHost,
       basePath: `/${r.npub}`,
+      zap,
     }),
   );
 });
diff --git a/src/routes/tenant.ts b/src/routes/tenant.ts
index a6d0515..187ce09 100644
--- a/src/routes/tenant.ts
+++ b/src/routes/tenant.ts
@@ -10,8 +10,11 @@ import {
   rowToEvent,
 } from "../services/events";
 import { getProfile as getProfileRow } from "../services/profiles";
+import { safeLud16, zapTotals } from "../services/zaps";
+import { naddrEncode } from "../nostr/nip19";
+import { selfRelayUrl } from "../relay/url";
 import { BlogHome } from "../views/tenant/home";
-import { PostPage } from "../views/tenant/post";
+import { PostPage, type PostZap } from "../views/tenant/post";
 import { NotFoundPage } from "../views/tenant/not-found";
 import { rssFeed, atomFeed, sitemapXml } from "../views/tenant/xml";
 
@@ -49,7 +52,12 @@ const d1Provider: TenantDataProvider = {
   async getProfile(env, pubkey) {
     const row = await getProfileRow(env, pubkey);
     if (!row) return null;
-    return { name: row.name, picture: row.picture, about: row.about };
+    return {
+      name: row.name,
+      picture: row.picture,
+      about: row.about,
+      lud16: row.lud16,
+    };
   },
   async listPosts(env, pubkey) {
     const rows = await listPostsByPubkey(env, pubkey);
@@ -125,6 +133,40 @@ function notFound(c: Context<DispatchEnv>) {
   return c.html(NotFoundPage({ handle }), 404);
 }
 
+/**
+ * Zap affordance for a post (#12 v1): only when the author's kind 0 carries
+ * a shape-valid lud16. The naddr hints our first-party relay so a hand-off
+ * client can find the post; totals come from the zap_totals rollup. A d-tag
+ * too long for nip19 TLV (255 bytes) simply drops the affordance.
+ */
+export async function postZap(
+  env: Env,
+  pubkey: string,
+  dTag: string,
+  lud16Raw: string | null | undefined,
+): Promise<PostZap | null> {
+  const lud16 = safeLud16(lud16Raw);
+  if (lud16 === null) return null;
+  let naddr: string;
+  try {
+    naddr = naddrEncode({
+      identifier: dTag,
+      pubkey,
+      kind: 30023,
+      relays: [selfRelayUrl(env)],
+    });
+  } catch {
+    return null;
+  }
+  const totals = await zapTotals(env, `30023:${pubkey}:${dTag}`);
+  return {
+    lud16,
+    naddr,
+    msatTotal: totals?.msatTotal ?? 0,
+    zapCount: totals?.zapCount ?? 0,
+  };
+}
+
 /** Routes served on blog subdomains (<handle>.MAIN_HOST). */
 export const tenantRoutes = new Hono<DispatchEnv>();
 
@@ -216,6 +258,7 @@ tenantRoutes.get("/:slug", async (c) => {
     return notFound(c);
   }
   const profile = await provider.getProfile(c.env, ctx.pubkey);
+  const zap = await postZap(c.env, ctx.pubkey, slug, profile?.lud16);
   return c.html(
     PostPage({
       handle: ctx.handle,
@@ -225,6 +268,7 @@ tenantRoutes.get("/:slug", async (c) => {
       about: ctx.about,
       themeCss: ctx.themeCss,
       mainHost: ctx.mainHost,
+      zap,
     }),
   );
 });
diff --git a/src/services/events.ts b/src/services/events.ts
index 48a77a3..6462a32 100644
--- a/src/services/events.ts
+++ b/src/services/events.ts
@@ -121,7 +121,15 @@ export const FEED_CONTENT_PREFIX_CHARS = 2048;
 export const FEED_SELECT_COLUMNS =
   "e.id, e.pubkey, e.kind, e.d_tag, e.created_at, e.tags, " +
   `substr(e.content, 1, ${FEED_CONTENT_PREFIX_CHARS}) AS content, ` +
-  "u.handle AS handle";
+  "u.handle AS handle, zt.msat_total AS zap_msat, zt.zap_count AS zap_count";
+
+/**
+ * LEFT JOIN clause pairing FEED_SELECT_COLUMNS' zap columns (#12): the
+ * zap_totals rollup keyed by the post's a-coordinate. The concatenation
+ * resolves per row and then hits zap_totals' PRIMARY KEY index — no scan.
+ */
+export const FEED_ZAP_JOIN =
+  "LEFT JOIN zap_totals zt ON zt.address = '30023:' || e.pubkey || ':' || e.d_tag";
 
 /**
  * A slim feed row: the events columns the discover/search pages actually
@@ -131,7 +139,7 @@ export const FEED_SELECT_COLUMNS =
 export type FeedRow = Pick<
   EventRow,
   "id" | "pubkey" | "kind" | "d_tag" | "created_at" | "content" | "tags"
-> & { handle: string };
+> & { handle: string; zap_msat: number | null; zap_count: number | null };
 
 /**
  * Recent posts across ALL claimed, non-blocked users, newest first (P6
@@ -163,6 +171,7 @@ export async function listRecentClaimedPosts(
     `SELECT ${FEED_SELECT_COLUMNS}
      FROM events e
      JOIN users u ON u.pubkey = e.pubkey
+     ${FEED_ZAP_JOIN}
      WHERE e.kind = 30023 AND e.deleted = 0
        AND u.handle IS NOT NULL AND u.blocked = 0
      ORDER BY e.created_at DESC, e.id ASC
diff --git a/src/services/search.ts b/src/services/search.ts
index d896384..c68ec44 100644
--- a/src/services/search.ts
+++ b/src/services/search.ts
@@ -1,6 +1,7 @@
 import {
   DISCOVER_PAGE_SIZE,
   FEED_SELECT_COLUMNS,
+  FEED_ZAP_JOIN,
   type FeedRow,
 } from "./events";
 
@@ -83,6 +84,7 @@ export async function searchPosts(
        FROM posts_fts
        JOIN events e ON e.rowid = posts_fts.rowid
        JOIN users u ON u.pubkey = e.pubkey
+       ${FEED_ZAP_JOIN}
        WHERE posts_fts MATCH ?1
          AND e.kind = 30023 AND e.deleted = 0
          AND u.handle IS NOT NULL AND u.blocked = 0
diff --git a/src/services/zaps.ts b/src/services/zaps.ts
new file mode 100644
index 0000000..1607a13
--- /dev/null
+++ b/src/services/zaps.ts
@@ -0,0 +1,552 @@
+/**
+ * NIP-57 zaps (#12 v1): server-side validation + aggregation of kind 9735
+ * zap receipts referencing claimed authors' long-form posts.
+ *
+ * Trust model: a receipt only counts when
+ *   1. its signature verifies (schnorr, like every mirrored event);
+ *   2. its `pubkey` equals the author's LNURL-pay `nostrPubkey` (resolved
+ *      from the author's kind-0 `lud16`, cached in D1) — so only the
+ *      author's own wallet provider can mint countable receipts;
+ *   3. its embedded 9734 zap request targets the author (`p`) and one of the
+ *      author's stored posts (`a` = 30023:<author>:<d_tag>);
+ *   4. the bolt11 invoice amount matches the 9734 `amount` tag (both parsed
+ *      here — HRP only, no full bolt11 decode).
+ * Receipts are deduped by event id; totals are rebuilt idempotently per
+ * address so a crash between statements can never leave drifted counts.
+ *
+ * The first-party relay cannot hold 9735 (kind allowlist + NIP-42 claimed
+ * writes), so receipts are read from the user's configured relays + service
+ * defaults only.
+ */
+import { verifyEvent, type NostrEvent } from "../nostr/event";
+import { fetchEvents } from "../nostr/relay";
+import { bumpGen } from "./mirror";
+import { getProfile } from "./profiles";
+import { readBlogSettings, type User } from "./users";
+import { isSelfRelayHost } from "../relay/url";
+
+/** Max NEW receipts verified+stored per user per cron run (schnorr budget). */
+export const ZAP_VERIFY_CAP = 10;
+
+/** Relay filter limit for the 9735 fetch (one page per run, no paging). */
+const ZAP_FETCH_LIMIT = 60;
+
+/** Relay collection deadline for the zap pass (matches refresh). */
+const ZAP_TIMEOUT_MS = 8_000;
+
+/** Far-future skew guard (mirrors cron/refresh.ts MAX_FUTURE_SKEW_SECONDS). */
+const ZAP_MAX_FUTURE_SKEW_SECONDS = 900;
+
+/** LNURL nostrPubkey cache TTL — lud16 endpoints change rarely. */
+export const LNURL_CACHE_TTL_SECONDS = 24 * 60 * 60;
+
+/** Response byte cap for the LNURL-pay .well-known fetch. */
+const LNURL_MAX_RESPONSE_BYTES = 65_536;
+
+/** LNURL fetch deadline. */
+const LNURL_TIMEOUT_MS = 8_000;
+
+/**
+ * Per-receipt amount ceiling (msat). Amounts are attacker-influenced relay
+ * data feeding integer arithmetic and rollup sums; 1e15 msat (10 BTC) is far
+ * beyond any real zap and keeps every sum well inside Number.MAX_SAFE_INTEGER.
+ */
+export const MAX_ZAP_MSAT = 1_000_000_000_000_000;
+
+const HEX_64 = /^[0-9a-f]{64}$/;
+
+// --- lud16 -------------------------------------------------------------------
+
+/**
+ * Shape-validate a lightning address (LUD-16 `user@domain`). lud16 is
+ * untrusted kind-0 relay content that ends up in `lightning:` hrefs and in
+ * the LNURL-pay URL this module fetches — reject anything that is not a
+ * plain local-part@registered-domain (no ports, no IP literals, no
+ * userinfo/path tricks). Returns the address with the DOMAIN lowercased, or
+ * null.
+ */
+export function safeLud16(value: string | null | undefined): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.length > 320) return null;
+  const at = trimmed.lastIndexOf("@");
+  if (at <= 0 || at === trimmed.length - 1) return null;
+  const local = trimmed.slice(0, at);
+  const domain = trimmed.slice(at + 1).toLowerCase();
+  if (!/^[a-z0-9._+-]+$/i.test(local)) return null;
+  // Registered names only: letters/digits/hyphens labels, alpha TLD — this
+  // structurally excludes IPv4/IPv6 literals, localhost (single label), and
+  // port suffixes.
+  if (!/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/.test(domain)) {
+    return null;
+  }
+  return `${local}@${domain}`;
+}
+
+/** LNURL-pay endpoint URL for a safeLud16-validated address. */
+export function lnurlpUrl(lud16: string): string {
+  const at = lud16.lastIndexOf("@");
+  const local = lud16.slice(0, at);
+  const domain = lud16.slice(at + 1);
+  return `https://${domain}/.well-known/lnurlp/${encodeURIComponent(local)}`;
+}
+
+// --- bolt11 amount -----------------------------------------------------------
+
+/**
+ * Millisat amount from a bolt11 invoice's human-readable part. Mainnet
+ * (`lnbc`) only; requires an explicit amount (zap invoices always carry
+ * one). HRP amount is in BTC scaled by the multiplier: m=1e-3, u=1e-6,
+ * n=1e-9, p=1e-12; 1 BTC = 1e11 msat. Integer math throughout; `p` amounts
+ * not divisible by 10 (sub-msat) and anything over MAX_ZAP_MSAT return null.
+ */
+export function bolt11Msat(invoice: string | undefined): number | null {
+  if (typeof invoice !== "string") return null;
+  const m = /^lnbc(\d+)([munp])?1/i.exec(invoice.trim());
+  if (!m) return null;
+  const digitsStr = m[1]!;
+  if (digitsStr.length > 15) return null; // overflow guard before Number()
+  const digits = Number(digitsStr);
+  if (!Number.isSafeInteger(digits) || digits <= 0) return null;
+  let msat: number;
+  switch (m[2]?.toLowerCase()) {
+    case undefined:
+      msat = digits * 100_000_000_000;
+      break;
+    case "m":
+      msat = digits * 100_000_000;
+      break;
+    case "u":
+      msat = digits * 100_000;
+      break;
+    case "n":
+      msat = digits * 100;
+      break;
+    case "p":
+      if (digits % 10 !== 0) return null;
+      msat = digits / 10;
+      break;
+    default:
+      return null;
+  }
+  if (!Number.isSafeInteger(msat) || msat <= 0 || msat > MAX_ZAP_MSAT) {
+    return null;
+  }
+  return msat;
+}
+
+// --- receipt validation ------------------------------------------------------
+
+/** First value of the first tag named `name`, or undefined. */
+function firstTag(tags: string[][], name: string): string | undefined {
+  for (const tag of tags) {
+    if (tag[0] === name && typeof tag[1] === "string") return tag[1];
+  }
+  return undefined;
+}
+
+export type ParsedZapReceipt = {
+  receiptId: string;
+  address: string; // 30023:<author>:<d_tag>
+  dTag: string;
+  authorPubkey: string;
+  senderPubkey: string | null; // the 9734 signer (ephemeral for anon zaps)
+  amountMsat: number;
+  createdAt: number;
+};
+
+/**
+ * Structural NIP-57 receipt validation (no crypto — verifyEvent is the
+ * caller's job, AFTER the cheap checks and the nostrPubkey binding). Returns
+ * null unless every appendix rule that can be checked offline holds:
+ * receipt targets the author via `p`; its `a` is an address of the author's
+ * (30023 only); the `description` parses to a kind 9734 whose `p`/`a` match
+ * and whose `amount` equals the bolt11 invoice amount.
+ */
+export function parseZapReceipt(
+  ev: NostrEvent,
+  authorPubkey: string,
+): ParsedZapReceipt | null {
+  if (ev.kind !== 9735) return null;
+  if (firstTag(ev.tags, "p") !== authorPubkey) return null;
+
+  const address = firstTag(ev.tags, "a");
+  if (address === undefined) return null;
+  const addrMatch = /^30023:([0-9a-f]{64}):([\s\S]*)$/.exec(address);
+  if (!addrMatch || addrMatch[1] !== authorPubkey) return null;
+  const dTag = addrMatch[2] ?? "";
+
+  const description = firstTag(ev.tags, "description");
+  if (description === undefined) return null;
+  let request: unknown;
+  try {
+    request = JSON.parse(description);
+  } catch {
+    return null;
+  }
+  if (request === null || typeof request !== "object" || Array.isArray(request)) {
+    return null;
+  }
+  const req = request as Record<string, unknown>;
+  if (req.kind !== 9734) return null;
+  if (typeof req.pubkey !== "string" || !HEX_64.test(req.pubkey)) return null;
+  if (!Array.isArray(req.tags)) return null;
+  const reqTags = req.tags.filter(
+    (t): t is string[] =>
+      Array.isArray(t) && t.every((item) => typeof item === "string"),
+  );
+  if (firstTag(reqTags, "p") !== authorPubkey) return null;
+  if (firstTag(reqTags, "a") !== address) return null;
+
+  // The invoice is the authoritative amount source (it is what was paid).
+  // NIP-57 makes the 9734 `amount` tag optional; when present it must equal
+  // the invoice amount (appendix rule) — wallets that omit it still count.
+  const invoiceMsat = bolt11Msat(firstTag(ev.tags, "bolt11"));
+  if (invoiceMsat === null) return null;
+  const amountStr = firstTag(reqTags, "amount");
+  if (amountStr !== undefined) {
+    if (!/^\d{1,15}$/.test(amountStr)) return null;
+    if (Number(amountStr) !== invoiceMsat) return null;
+  }
+  const amountMsat = invoiceMsat;
+
+  return {
+    receiptId: ev.id,
+    address,
+    dTag,
+    authorPubkey,
+    senderPubkey: req.pubkey,
+    amountMsat,
+    createdAt: ev.created_at,
+  };
+}
+
+// --- LNURL nostrPubkey resolution -------------------------------------------
+
+/**
+ * Injectable LNURL fetcher seam (tests swap the network call — same pattern
+ * as the Turnstile verifier). Returns the endpoint's nostrPubkey when the
+ * endpoint advertises `allowsNostr: true`, else null.
+ */
+export type LnurlFetcher = (url: string) => Promise<string | null>;
+
+const realLnurlFetcher: LnurlFetcher = async (url) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), LNURL_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" },
+    });
+    if (!res.ok || !res.body) return null;
+    // Byte-capped read: the domain comes from attacker-influenced lud16 and
+    // must not stream an unbounded body into memory.
+    const reader = res.body.getReader();
+    const chunks: Uint8Array[] = [];
+    let total = 0;
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > LNURL_MAX_RESPONSE_BYTES) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(value);
+    }
+    const body = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      body.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const data: unknown = JSON.parse(new TextDecoder().decode(body));
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+      return null;
+    }
+    const d = data as Record<string, unknown>;
+    if (d.allowsNostr !== true) return null;
+    if (typeof d.nostrPubkey !== "string") return null;
+    const pk = d.nostrPubkey.toLowerCase();
+    return HEX_64.test(pk) ? pk : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+let lnurlFetcher: LnurlFetcher = realLnurlFetcher;
+
+/** TEST ONLY: swap the LNURL fetcher. Pass null to restore the real one. */
+export function setLnurlFetcherForTests(fn: LnurlFetcher | null): void {
+  lnurlFetcher = fn ?? realLnurlFetcher;
+}
+
+/**
+ * The author's LNURL-pay nostrPubkey for a validated lud16, through the D1
+ * cache (TTL LNURL_CACHE_TTL_SECONDS — negative results cache too, so a dead
+ * endpoint costs one subrequest per TTL, not one per run).
+ */
+export async function resolveNostrPubkey(
+  env: Env,
+  lud16: string,
+): Promise<string | null> {
+  const now = Math.floor(Date.now() / 1000);
+  const cached = await env.DB.prepare(
+    "SELECT nostr_pubkey, checked_at FROM lnurl_cache WHERE lud16 = ?",
+  )
+    .bind(lud16)
+    .first<{ nostr_pubkey: string | null; checked_at: number }>();
+  if (cached && now - cached.checked_at < LNURL_CACHE_TTL_SECONDS) {
+    return cached.nostr_pubkey;
+  }
+  const pubkey = await lnurlFetcher(lnurlpUrl(lud16));
+  await env.DB.prepare(
+    `INSERT INTO lnurl_cache (lud16, nostr_pubkey, checked_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(lud16) DO UPDATE SET
+       nostr_pubkey = excluded.nostr_pubkey,
+       checked_at = excluded.checked_at`,
+  )
+    .bind(lud16, pubkey, now)
+    .run();
+  return pubkey;
+}
+
+// --- storage -----------------------------------------------------------------
+
+/** Which of `ids` are already-stored receipt ids. */
+async function storedZapIds(env: Env, ids: string[]): Promise<Set<string>> {
+  const stored = new Set<string>();
+  for (let i = 0; i < ids.length; i += 50) {
+    const chunk = ids.slice(i, i + 50);
+    const placeholders = chunk.map(() => "?").join(", ");
+    const rs = await env.DB.prepare(
+      `SELECT receipt_id FROM zaps WHERE receipt_id IN (${placeholders})`,
+    )
+      .bind(...chunk)
+      .all<{ receipt_id: string }>();
+    for (const row of rs.results) stored.add(row.receipt_id);
+  }
+  return stored;
+}
+
+/**
+ * Store one validated receipt and rebuild its address rollup. The rollup is
+ * recomputed FROM the zaps table in the same atomic batch (INSERT OR IGNORE
+ * + SELECT-based upsert), so replays and races converge on correct totals.
+ */
+export async function storeZapReceipt(
+  env: Env,
+  zap: ParsedZapReceipt,
+): Promise<void> {
+  await env.DB.batch([
+    env.DB.prepare(
+      `INSERT OR IGNORE INTO zaps
+         (receipt_id, address, author_pubkey, sender_pubkey, amount_msat, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+    ).bind(
+      zap.receiptId,
+      zap.address,
+      zap.authorPubkey,
+      zap.senderPubkey,
+      zap.amountMsat,
+      zap.createdAt,
+    ),
+    env.DB.prepare(
+      `INSERT INTO zap_totals (address, msat_total, zap_count)
+       SELECT address, SUM(amount_msat), COUNT(*) FROM zaps WHERE address = ?
+       ON CONFLICT(address) DO UPDATE SET
+         msat_total = excluded.msat_total, zap_count = excluded.zap_count`,
+    ).bind(zap.address),
+  ]);
+}
+
+export type ZapTotals = { msatTotal: number; zapCount: number };
+
+/** Rollup totals for a post address, or null when never zapped. */
+export async function zapTotals(
+  env: Env,
+  address: string,
+): Promise<ZapTotals | null> {
+  const row = await env.DB.prepare(
+    "SELECT msat_total, zap_count FROM zap_totals WHERE address = ?",
+  )
+    .bind(address)
+    .first<{ msat_total: number; zap_count: number }>();
+  return row ? { msatTotal: row.msat_total, zapCount: row.zap_count } : null;
+}
+
+// --- cron pass ---------------------------------------------------------------
+
+/** Read the zap sync watermark from a users.settings blob (0 when unset). */
+export function readZapSince(settings: string): number {
+  try {
+    const parsed: unknown = JSON.parse(settings);
+    if (parsed !== null && typeof parsed === "object") {
+      const sync = (parsed as Record<string, unknown>).sync;
+      if (sync !== null && typeof sync === "object") {
+        const since = (sync as Record<string, unknown>).zap_since;
+        if (typeof since === "number" && Number.isFinite(since) && since >= 0) {
+          return Math.floor(since);
+        }
+      }
+    }
+  } catch {
+    // malformed settings → start from 0
+  }
+  return 0;
+}
+
+/** Persist the zap watermark ($.sync.zap_since — same discipline as $.sync.since). */
+async function writeZapSince(
+  env: Env,
+  pubkey: string,
+  since: number,
+): Promise<void> {
+  await env.DB.prepare(
+    `UPDATE users SET settings = json_set(
+       CASE
+         WHEN json_valid(settings) AND json_type(settings) = 'object' THEN
+           CASE WHEN json_type(settings, '$.sync') = 'object' THEN settings
+                ELSE json_set(settings, '$.sync', json('{}')) END
+         ELSE '{}'
+       END,
+       '$.sync.zap_since', ?
+     ) WHERE pubkey = ?`,
+  )
+    .bind(since, pubkey)
+    .run();
+}
+
+/** Does the zapped post actually exist (stored, owned, not deleted)? */
+async function postExists(
+  env: Env,
+  pubkey: string,
+  dTag: string,
+): Promise<boolean> {
+  const row = await env.DB.prepare(
+    `SELECT 1 FROM events
+     WHERE pubkey = ? AND kind = 30023 AND d_tag = ? AND deleted = 0`,
+  )
+    .bind(pubkey, dTag)
+    .first();
+  return row !== null;
+}
+
+/**
+ * Zap ingestion for one user (called from the cron loop after the post
+ * refresh). Skips users without a shape-valid lud16 or a resolvable
+ * nostrPubkey — without the wallet key there is nothing to bind receipts to.
+ *
+ * Watermark rules (same contract as cron/refresh.ts — every one closes a
+ * suppression hole, because the `#p` filter is satisfiable by ANYONE):
+ *   - only VERIFIED receipts advance it: stored rows and stored-dedup hits.
+ *     Junk from other pubkeys, parse-failures, and signature failures never
+ *     do — the `pubkey` field is attacker-claimable without a valid sig, so
+ *     advancing over anything unverified would let one far-future spam
+ *     event per run permanently outrun every real receipt. The cost is
+ *     refetching bounded junk each run (one page, no crypto spent on it);
+ *   - a verified receipt DEFERRED because its post is not mirrored yet
+ *     holds the watermark below itself, so it still counts once the post
+ *     lands via refresh — a later stored receipt must not advance past it;
+ *   - far-future created_at values are skipped entirely (clock skew /
+ *     forgery) and clamp the persisted value;
+ *   - it persists only over a CLOSED relay window (batch below the fetch
+ *     limit): NIP-01 `limit` keeps the newest matches, so a full page may
+ *     have silently dropped older receipts.
+ */
+export async function refreshZapsForUser(
+  env: Env,
+  baseRelays: string[],
+  user: User,
+): Promise<void> {
+  const profile = await getProfile(env, user.pubkey);
+  const lud16 = safeLud16(profile?.lud16);
+  if (lud16 === null) return;
+  const nostrPubkey = await resolveNostrPubkey(env, lud16);
+  if (nostrPubkey === null) return;
+
+  const configured = readBlogSettings(user.settings).relays;
+  const relays = [...new Set([...configured, ...baseRelays])].filter(
+    (url) => !isSelfRelayHost(url, env),
+  );
+  if (relays.length === 0) return;
+
+  const since = readZapSince(user.settings);
+  const filter: Record<string, unknown> = {
+    kinds: [9735],
+    "#p": [user.pubkey],
+    limit: ZAP_FETCH_LIMIT,
+  };
+  if (since > 0) filter.since = since;
+  const batch = await fetchEvents(relays, filter, ZAP_TIMEOUT_MS);
+  const windowClosed = batch.length < ZAP_FETCH_LIMIT;
+
+  // Cheap pre-filters before any crypto: right kind, right wallet key.
+  // (Non-candidates are unverified junk — they NEVER touch the watermark.)
+  const candidates = batch
+    .filter((ev) => ev.kind === 9735 && ev.pubkey === nostrPubkey)
+    .sort((a, b) => a.created_at - b.created_at || (a.id < b.id ? -1 : 1));
+
+  const stored = await storedZapIds(
+    env,
+    candidates.map((ev) => ev.id),
+  );
+  const maxPlausible =
+    Math.floor(Date.now() / 1000) + ZAP_MAX_FUTURE_SKEW_SECONDS;
+
+  let credits = ZAP_VERIFY_CAP;
+  let watermark = since;
+  // Oldest skipped-but-still-storable receipt: the persisted watermark must
+  // stay BELOW it (deferred post-not-mirrored receipts, cap-out remainder).
+  let holdBefore: number | null = null;
+  let storedAny = false;
+  for (const ev of candidates) {
+    if (ev.created_at > maxPlausible) continue; // forged/skewed — never advance
+    if (stored.has(ev.id)) {
+      // Verified when it was stored — safe to advance past it.
+      if (ev.created_at > watermark) watermark = ev.created_at;
+      continue;
+    }
+    const parsed = parseZapReceipt(ev, user.pubkey);
+    // Structurally uncountable — but UNVERIFIED (the pubkey field costs an
+    // attacker nothing), so it must not advance the watermark either. It is
+    // refetched next run and re-fails the same cheap parse; no crypto spent.
+    if (parsed === null) continue;
+    if (credits === 0) {
+      // Candidates are oldest-first, so this is the oldest unprocessed one —
+      // but an even older DEFERRED receipt may already hold the watermark
+      // lower; keep the minimum. Resume next tick.
+      if (holdBefore === null || ev.created_at < holdBefore) {
+        holdBefore = ev.created_at;
+      }
+      break;
+    }
+    credits--;
+    if (!(await verifyEvent(ev))) continue; // forged — never advance
+    if (!(await postExists(env, user.pubkey, parsed.dTag))) {
+      // Valid receipt for a post we do not mirror (yet): defer — hold the
+      // watermark below it so it still counts once the post lands, even
+      // when a NEWER receipt is stored later in this same loop.
+      if (holdBefore === null || ev.created_at < holdBefore) {
+        holdBefore = ev.created_at;
+      }
+      continue;
+    }
+    await storeZapReceipt(env, parsed);
+    storedAny = true;
+    if (ev.created_at > watermark) watermark = ev.created_at;
+  }
+
+  if (storedAny) await bumpGen(env, user.pubkey);
+
+  if (holdBefore !== null) watermark = Math.min(watermark, holdBefore - 1);
+  watermark = Math.min(watermark, maxPlausible);
+  // Persist only over a closed window: a full page may have truncated older
+  // receipts the `since` filter would then skip forever.
+  if (windowClosed && watermark > since) {
+    await writeZapSince(env, user.pubkey, watermark);
+  }
+}
diff --git a/src/views/main/feed.tsx b/src/views/main/feed.tsx
index 34c035f..d6ee95f 100644
--- a/src/views/main/feed.tsx
+++ b/src/views/main/feed.tsx
@@ -19,6 +19,9 @@ export type FeedItem = {
   url: string;
   /** Absolute URL of the author's blog home. */
   blogUrl: string;
+  /** Zap rollup (#12): whole sats + receipt count; 0/0 when never zapped. */
+  zapSats: number;
+  zapCount: number;
 };
 
 /** Map joined event rows to renderable feed items. */
@@ -41,6 +44,11 @@ export function feedItems(rows: FeedRow[], mainHost: string): FeedItem[] {
           ? blogUrl
           : `${blogUrl}${encodeURIComponent(meta.slug)}`,
       blogUrl,
+      zapSats:
+        typeof row.zap_msat === "number" && row.zap_msat > 0
+          ? Math.floor(row.zap_msat / 1000)
+          : 0,
+      zapCount: typeof row.zap_count === "number" ? row.zap_count : 0,
     };
   });
 }
@@ -60,6 +68,13 @@ export function FeedList(props: { items: FeedItem[] }) {
           <time class="post-date" datetime={item.date}>
             {item.date}
           </time>
+          {item.zapCount > 0 ? (
+            <span class="post-zaps">
+              {" "}
+              ⚡ {item.zapSats.toLocaleString("en-US")} sats ·{" "}
+              {item.zapCount} {item.zapCount === 1 ? "zap" : "zaps"}
+            </span>
+          ) : null}
           {item.summary ? <p class="post-summary">{item.summary}</p> : null}
         </li>
       ))}
diff --git a/src/views/tenant/layout.tsx b/src/views/tenant/layout.tsx
index da2cac7..700cd21 100644
--- a/src/views/tenant/layout.tsx
+++ b/src/views/tenant/layout.tsx
@@ -12,6 +12,9 @@ export type BlogProfile = {
   name: string | null;
   picture: string | null;
   about: string | null;
+  /** Lightning address from the kind 0 (zap affordance) — untrusted; views
+   *  must gate on safeLud16 before building any href from it. */
+  lud16: string | null;
 };
 
 /**
diff --git a/src/views/tenant/post.tsx b/src/views/tenant/post.tsx
index 3c362c2..3fd9132 100644
--- a/src/views/tenant/post.tsx
+++ b/src/views/tenant/post.tsx
@@ -3,7 +3,21 @@ import type { NostrEvent } from "../../nostr/event";
 import { postMeta, isoDate } from "../../markdown/nip23";
 
 /**
- * Post page: title, published_at, rendered content.
+ * Zap affordance data (#12 v1), precomputed by the ROUTE: `lud16` has passed
+ * safeLud16 (shape-validated, safe inside a `lightning:` href) and `naddr`
+ * is our own nip19 encoding of the post address. Totals come from the
+ * zap_totals rollup. Everything renders as plain server-side links/text —
+ * blog pages stay JS-free (BLOG_CSP has no script-src).
+ */
+export type PostZap = {
+  lud16: string;
+  naddr: string;
+  msatTotal: number;
+  zapCount: number;
+};
+
+/**
+ * Post page: title, published_at, rendered content, zap footer.
  *
  * `bodyHtml` is the renderPost output (markdown-it html:false + allowlist
  * sanitizer) that mirrorEvent stored at INGEST time (events.rendered) — the
@@ -19,9 +33,12 @@ export function PostPage(props: {
   themeCss?: string;
   mainHost: string;
   basePath?: string;
+  zap?: PostZap | null;
 }) {
   const meta = postMeta(props.event);
   const date = isoDate(meta.published_at);
+  const zap = props.zap ?? null;
+  const sats = zap ? Math.floor(zap.msatTotal / 1000) : 0;
 
   return (
     <BlogLayout
@@ -47,6 +64,33 @@ export function PostPage(props: {
             class="post-content"
             dangerouslySetInnerHTML={{ __html: props.bodyHtml }}
           />
+          {zap ? (
+            <footer class="post-zap">
+              <p>
+                {/* Hand-off to a Nostr client for an ATTRIBUTED zap (its 9735
+                    references this post and feeds the counts); the lightning:
+                    link is the walletless plain-tip fallback (no receipt, not
+                    counted). */}
+                <a
+                  href={`https://njump.me/${zap.naddr}`}
+                  rel="noopener nofollow"
+                >
+                  ⚡ Zap this post
+                </a>
+                {" · "}
+                <a href={`lightning:${zap.lud16}`} rel="nofollow">
+                  tip {zap.lud16}
+                </a>
+                {zap.zapCount > 0 ? (
+                  <span class="zap-totals">
+                    {" · "}
+                    {sats.toLocaleString("en-US")} sats · {zap.zapCount}{" "}
+                    {zap.zapCount === 1 ? "zap" : "zaps"}
+                  </span>
+                ) : null}
+              </p>
+            </footer>
+          ) : null}
         </article>
       </main>
     </BlogLayout>
diff --git a/test/integration/tenant.spec.ts b/test/integration/tenant.spec.ts
index 85a560d..5add052 100644
--- a/test/integration/tenant.spec.ts
+++ b/test/integration/tenant.spec.ts
@@ -34,6 +34,7 @@ const fixtureProvider: TenantDataProvider = {
           name: aliceKind0.name,
           picture: aliceKind0.picture,
           about: aliceKind0.about,
+          lud16: null,
         }
       : null,
   listPosts: async (_env, pubkey) =>
diff --git a/test/integration/zaps.spec.ts b/test/integration/zaps.spec.ts
new file mode 100644
index 0000000..4324f1b
--- /dev/null
+++ b/test/integration/zaps.spec.ts
@@ -0,0 +1,313 @@
+// #12: zap ingestion + rendering — the cron receipt pass (LNURL nostrPubkey
+// binding, dedup, watermark), the rollup, the JS-free zap affordance on post
+// pages, and feed counts.
+import { SELF, env } from "cloudflare:test";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { finalizeEvent } from "nostr-tools/pure";
+import { hexToBytes } from "@noble/hashes/utils.js";
+import fixtures from "../fixtures/events.json";
+import keys from "../fixtures/keys.json";
+import {
+  ALICE_PK,
+  BOB_SK,
+  MALLORY_PK,
+  MALLORY_SK,
+  resetDiscoverCache,
+  resetMirrorState,
+  resetRateLimits,
+  resetUsers,
+  seedAlice,
+  signProfileEvent,
+} from "../helpers";
+import { serveEvents, resetMockRelay } from "../mock-relay";
+import type { NostrEvent } from "../../src/nostr/event";
+import { mirrorEvent } from "../../src/services/mirror";
+import { getUserByPubkey, type User } from "../../src/services/users";
+import {
+  parseZapReceipt,
+  readZapSince,
+  refreshZapsForUser,
+  resolveNostrPubkey,
+  setLnurlFetcherForTests,
+  storeZapReceipt,
+  zapTotals,
+} from "../../src/services/zaps";
+
+const aliceHello = fixtures.posts.aliceHello as NostrEvent;
+const ADDRESS = `30023:${ALICE_PK}:hello-world`;
+const AMOUNT_MSAT = 1_000_000; // 1,000 sats ↔ lnbc10u
+const BOLT11 = "lnbc10u1qqqqsdqqcqzysxq";
+const LUD16 = "alice@wallet.example";
+
+function zapRequest(address = ADDRESS): NostrEvent {
+  return finalizeEvent(
+    {
+      kind: 9734,
+      created_at: 1_700_050_000,
+      tags: [
+        ["relays", "wss://relay.example"],
+        ["p", ALICE_PK],
+        ["a", address],
+        ["amount", String(AMOUNT_MSAT)],
+      ],
+      content: "",
+    },
+    hexToBytes(BOB_SK),
+  ) as NostrEvent;
+}
+
+function zapReceipt(
+  opts: { address?: string; created_at?: number; sk?: string } = {},
+): NostrEvent {
+  const address = opts.address ?? ADDRESS;
+  return finalizeEvent(
+    {
+      kind: 9735,
+      created_at: opts.created_at ?? 1_700_050_001,
+      tags: [
+        ["p", ALICE_PK],
+        ["a", address],
+        ["bolt11", BOLT11],
+        ["description", JSON.stringify(zapRequest(address))],
+      ],
+      content: "",
+    },
+    hexToBytes(opts.sk ?? MALLORY_SK),
+  ) as NostrEvent;
+}
+
+async function aliceUser(): Promise<User> {
+  const user = await getUserByPubkey(env, ALICE_PK);
+  expect(user).not.toBeNull();
+  return user!;
+}
+
+/** Mirror alice's kind 0 (with the given lud16) and her hello-world post. */
+async function seedProfileAndPost(lud16: string = LUD16): Promise<void> {
+  expect(
+    await mirrorEvent(
+      env,
+      signProfileEvent({
+        created_at: 1_700_000_100,
+        content: { name: "alice", lud16 },
+      }),
+    ),
+  ).toBe("stored");
+  expect(await mirrorEvent(env, aliceHello)).toBe("stored");
+}
+
+beforeEach(async () => {
+  await resetMirrorState();
+  await resetRateLimits();
+  await resetUsers();
+  await seedAlice();
+  await resetDiscoverCache();
+  await env.DB.batch([
+    env.DB.prepare("DELETE FROM zaps"),
+    env.DB.prepare("DELETE FROM zap_totals"),
+    env.DB.prepare("DELETE FROM lnurl_cache"),
+  ]);
+});
+
+afterEach(() => {
+  resetMockRelay();
+  setLnurlFetcherForTests(null);
+});
+
+describe("storeZapReceipt / zapTotals", () => {
+  it("dedupes by receipt id and rolls up totals idempotently", async () => {
+    const first = parseZapReceipt(zapReceipt(), ALICE_PK)!;
+    const second = parseZapReceipt(
+      zapReceipt({ created_at: 1_700_050_010 }),
+      ALICE_PK,
+    )!;
+    await storeZapReceipt(env, first);
+    await storeZapReceipt(env, first); // replay — must not double-count
+    await storeZapReceipt(env, second);
+    expect(await zapTotals(env, ADDRESS)).toEqual({
+      msatTotal: 2 * AMOUNT_MSAT,
+      zapCount: 2,
+    });
+    expect(await zapTotals(env, `30023:${ALICE_PK}:other`)).toBeNull();
+  });
+});
+
+describe("resolveNostrPubkey", () => {
+  it("caches lookups (positive and negative) in D1", async () => {
+    let calls = 0;
+    setLnurlFetcherForTests(async () => {
+      calls++;
+      return MALLORY_PK;
+    });
+    expect(await resolveNostrPubkey(env, LUD16)).toBe(MALLORY_PK);
+    expect(await resolveNostrPubkey(env, LUD16)).toBe(MALLORY_PK);
+    expect(calls).toBe(1);
+
+    let deadCalls = 0;
+    setLnurlFetcherForTests(async () => {
+      deadCalls++;
+      return null;
+    });
+    expect(await resolveNostrPubkey(env, "dead@wallet.example")).toBeNull();
+    expect(await resolveNostrPubkey(env, "dead@wallet.example")).toBeNull();
+    expect(deadCalls).toBe(1);
+  });
+});
+
+describe("refreshZapsForUser", () => {
+  it("stores only wallet-signed, valid receipts and advances the watermark", async () => {
+    await seedProfileAndPost();
+    let lnurlCalls = 0;
+    setLnurlFetcherForTests(async () => {
+      lnurlCalls++;
+      return MALLORY_PK;
+    });
+    const valid = zapReceipt();
+    const wrongWallet = zapReceipt({ sk: BOB_SK, created_at: 1_700_050_002 });
+    serveEvents([valid, wrongWallet]);
+
+    await refreshZapsForUser(env, ["wss://mock.local"], await aliceUser());
+
+    expect(await zapTotals(env, ADDRESS)).toEqual({
+      msatTotal: AMOUNT_MSAT,
+      zapCount: 1,
+    });
+    expect(lnurlCalls).toBe(1);
+    const user = await aliceUser();
+    expect(readZapSince(user.settings)).toBe(valid.created_at);
+
+    // Second run over the same relay contents: dedup, no new rows, cached
+    // LNURL lookup.
+    await refreshZapsForUser(env, ["wss://mock.local"], user);
+    expect(await zapTotals(env, ADDRESS)).toEqual({
+      msatTotal: AMOUNT_MSAT,
+      zapCount: 1,
+    });
+    expect(lnurlCalls).toBe(1);
+  });
+
+  it("skips receipts for posts that are not mirrored WITHOUT advancing the watermark", async () => {
+    await seedProfileAndPost();
+    setLnurlFetcherForTests(async () => MALLORY_PK);
+    serveEvents([zapReceipt({ address: `30023:${ALICE_PK}:not-mirrored` })]);
+    await refreshZapsForUser(env, ["wss://mock.local"], await aliceUser());
+    expect(await zapTotals(env, `30023:${ALICE_PK}:not-mirrored`)).toBeNull();
+    // Deferred, not dropped: the receipt must count once the post lands.
+    expect(readZapSince((await aliceUser()).settings)).toBe(0);
+  });
+
+  it("junk from other pubkeys NEVER advances the watermark (suppression guard)", async () => {
+    // One spam 9735 per run with a near-future created_at would otherwise
+    // outrun every real receipt forever (the #p filter is attacker-satisfiable).
+    await seedProfileAndPost();
+    setLnurlFetcherForTests(async () => MALLORY_PK);
+    serveEvents([
+      zapReceipt({ sk: BOB_SK, created_at: Math.floor(Date.now() / 1000) + 800 }),
+    ]);
+    await refreshZapsForUser(env, ["wss://mock.local"], await aliceUser());
+    expect(readZapSince((await aliceUser()).settings)).toBe(0);
+  });
+
+  it("a deferred receipt holds the watermark below itself past newer stored ones", async () => {
+    await seedProfileAndPost();
+    setLnurlFetcherForTests(async () => MALLORY_PK);
+    const deferred = zapReceipt({
+      address: `30023:${ALICE_PK}:landing-later`,
+      created_at: 1_700_050_005,
+    });
+    const newerStored = zapReceipt({ created_at: 1_700_050_020 });
+    serveEvents([deferred, newerStored]);
+
+    await refreshZapsForUser(env, ["wss://mock.local"], await aliceUser());
+    // The newer receipt stored, but the watermark stayed below the deferred
+    // one so it is refetched next run.
+    expect(await zapTotals(env, ADDRESS)).toEqual({
+      msatTotal: AMOUNT_MSAT,
+      zapCount: 1,
+    });
+    expect(readZapSince((await aliceUser()).settings)).toBe(
+      deferred.created_at - 1,
+    );
+
+    // The post lands via refresh; the next zap run counts the deferred receipt.
+    const post = finalizeEvent(
+      {
+        kind: 30023,
+        created_at: 1_700_000_300,
+        tags: [
+          ["d", "landing-later"],
+          ["title", "Landing later"],
+          ["published_at", "1700000300"],
+        ],
+        content: "hello",
+      },
+      hexToBytes(keys.alice.sk),
+    ) as NostrEvent;
+    expect(await mirrorEvent(env, post)).toBe("stored");
+    await refreshZapsForUser(env, ["wss://mock.local"], await aliceUser());
+    expect(await zapTotals(env, `30023:${ALICE_PK}:landing-later`)).toEqual({
+      msatTotal: AMOUNT_MSAT,
+      zapCount: 1,
+    });
+    expect(readZapSince((await aliceUser()).settings)).toBe(
+      newerStored.created_at,
+    );
+  });
+
+  it("does nothing for a user without a valid lud16", async () => {
+    await seedProfileAndPost("not a lightning address");
+    let calls = 0;
+    setLnurlFetcherForTests(async () => {
+      calls++;
+      return MALLORY_PK;
+    });
+    serveEvents([zapReceipt()]);
+    await refreshZapsForUser(env, ["wss://mock.local"], await aliceUser());
+    expect(calls).toBe(0);
+    expect(await zapTotals(env, ADDRESS)).toBeNull();
+  });
+});
+
+describe("zap affordance on blog pages (JS-free)", () => {
+  it("renders the zap link, tip link, and totals on the post page", async () => {
+    await seedProfileAndPost();
+    await storeZapReceipt(env, parseZapReceipt(zapReceipt(), ALICE_PK)!);
+
+    const res = await SELF.fetch("https://alice.nbread.lol/hello-world");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("⚡ Zap this post");
+    expect(html).toContain('href="https://njump.me/naddr1');
+    expect(html).toContain(`href="lightning:${LUD16}"`);
+    expect(html).toContain("1,000 sats");
+    expect(html).toContain("1 zap");
+    // Still zero scripts on blog markup (BLOG_CSP contract).
+    expect(html).not.toContain("<script");
+  });
+
+  it("omits the affordance entirely without a lud16", async () => {
+    await seedProfileAndPost("");
+    const html = await (
+      await SELF.fetch("https://alice.nbread.lol/hello-world")
+    ).text();
+    expect(html).not.toContain("post-zap");
+    expect(html).not.toContain("njump.me");
+  });
+
+  it("never builds hrefs from a hostile lud16", async () => {
+    await seedProfileAndPost('x"onmouseover=alert(1)@127.0.0.1');
+    const html = await (
+      await SELF.fetch("https://alice.nbread.lol/hello-world")
+    ).text();
+    expect(html).not.toContain("post-zap");
+    expect(html).not.toContain("lightning:");
+  });
+
+  it("shows zap counts on the discover feed", async () => {
+    await seedProfileAndPost();
+    await storeZapReceipt(env, parseZapReceipt(zapReceipt(), ALICE_PK)!);
+    const html = await (await SELF.fetch("https://nbread.lol/discover")).text();
+    expect(html).toContain("⚡ 1,000 sats");
+    expect(html).toContain("1 zap");
+  });
+});
diff --git a/test/unit/zaps.spec.ts b/test/unit/zaps.spec.ts
new file mode 100644
index 0000000..f3cf878
--- /dev/null
+++ b/test/unit/zaps.spec.ts
@@ -0,0 +1,201 @@
+// #12: NIP-57 zap primitives — lud16 shape validation, bolt11 HRP amounts,
+// and the offline zap-receipt validation matrix.
+import { describe, expect, it } from "vitest";
+import { finalizeEvent } from "nostr-tools/pure";
+import { hexToBytes } from "@noble/hashes/utils.js";
+import keys from "../fixtures/keys.json";
+import type { NostrEvent } from "../../src/nostr/event";
+import {
+  bolt11Msat,
+  MAX_ZAP_MSAT,
+  parseZapReceipt,
+  safeLud16,
+  lnurlpUrl,
+} from "../../src/services/zaps";
+
+const ALICE_PK = keys.alice.pk; // the zapped author
+const BOB_SK = keys.bob.sk; // the zap sender (signs the 9734)
+const BOB_PK = keys.bob.pk;
+const MALLORY_SK = keys.mallory.sk; // the LNURL wallet key (signs the 9735)
+
+const ADDRESS = `30023:${ALICE_PK}:hello-world`;
+// 1,000,000 msat = 1,000 sats = 10 µBTC → HRP "lnbc10u".
+const AMOUNT_MSAT = 1_000_000;
+const BOLT11 = "lnbc10u1qqqqsdqqcqzysxq";
+
+function zapRequest(
+  overrides: {
+    p?: string | null;
+    a?: string | null;
+    amount?: string | null;
+    kind?: number;
+  } = {},
+): NostrEvent {
+  const tags: string[][] = [["relays", "wss://relay.example"]];
+  if (overrides.p !== null) tags.push(["p", overrides.p ?? ALICE_PK]);
+  if (overrides.a !== null) tags.push(["a", overrides.a ?? ADDRESS]);
+  if (overrides.amount !== null) {
+    tags.push(["amount", overrides.amount ?? String(AMOUNT_MSAT)]);
+  }
+  return finalizeEvent(
+    {
+      kind: overrides.kind ?? 9734,
+      created_at: 1_700_050_000,
+      tags,
+      content: "",
+    },
+    hexToBytes(BOB_SK),
+  ) as NostrEvent;
+}
+
+function zapReceipt(
+  overrides: {
+    request?: NostrEvent;
+    description?: string;
+    p?: string | null;
+    a?: string | null;
+    bolt11?: string | null;
+    created_at?: number;
+  } = {},
+): NostrEvent {
+  const tags: string[][] = [];
+  if (overrides.p !== null) tags.push(["p", overrides.p ?? ALICE_PK]);
+  if (overrides.a !== null) tags.push(["a", overrides.a ?? ADDRESS]);
+  if (overrides.bolt11 !== null) {
+    tags.push(["bolt11", overrides.bolt11 ?? BOLT11]);
+  }
+  tags.push([
+    "description",
+    overrides.description ?? JSON.stringify(overrides.request ?? zapRequest()),
+  ]);
+  return finalizeEvent(
+    {
+      kind: 9735,
+      created_at: overrides.created_at ?? 1_700_050_001,
+      tags,
+      content: "",
+    },
+    hexToBytes(MALLORY_SK),
+  ) as NostrEvent;
+}
+
+describe("safeLud16", () => {
+  it("accepts a plain lightning address and lowercases the domain", () => {
+    expect(safeLud16("alice@Wallet.Example")).toBe("alice@wallet.example");
+    expect(safeLud16("  a.b-c_d+e@sub.domain.example  ")).toBe(
+      "a.b-c_d+e@sub.domain.example",
+    );
+  });
+
+  it("rejects hostile or malformed values", () => {
+    for (const bad of [
+      null,
+      undefined,
+      "",
+      "no-at-sign",
+      "@example.com",
+      "user@",
+      "user@localhost", // single label
+      "user@127.0.0.1", // IPv4 literal (numeric TLD)
+      "user@[::1]",
+      "user@example.com:8443", // port
+      "user@example.com/path",
+      'user"onmouseover=x@example.com',
+      "user@exa mple.com",
+      "user@example.c", // 1-char TLD
+      "a".repeat(320) + "@example.com", // over the length cap
+    ]) {
+      expect(safeLud16(bad)).toBeNull();
+    }
+  });
+
+  it("builds the LUD-16 well-known URL with an encoded local part", () => {
+    expect(lnurlpUrl("alice+tips@wallet.example")).toBe(
+      "https://wallet.example/.well-known/lnurlp/alice%2Btips",
+    );
+  });
+});
+
+describe("bolt11Msat", () => {
+  it("parses HRP amounts across multipliers", () => {
+    expect(bolt11Msat("lnbc10u1qqq")).toBe(1_000_000); // 10 µBTC
+    expect(bolt11Msat("lnbc1m1qqq")).toBe(100_000_000); // 1 mBTC
+    expect(bolt11Msat("lnbc2500u1qqq")).toBe(250_000_000);
+    expect(bolt11Msat("lnbc100n1qqq")).toBe(10_000); // 100 nBTC = 10 sats
+    expect(bolt11Msat("lnbc250p1qqq")).toBe(25); // 250 pBTC = 25 msat
+    expect(bolt11Msat("LNBC10U1QQQ")).toBe(1_000_000); // case-insensitive
+  });
+
+  it("digits containing the separator character parse correctly", () => {
+    // amount 11 BTC → "lnbc11" + separator "1" + data (bech32 data has no '1')
+    expect(bolt11Msat("lnbc111qqq")).toBe(11 * 100_000_000_000);
+  });
+
+  it("rejects amount-less, sub-msat, non-mainnet, and oversized invoices", () => {
+    expect(bolt11Msat(undefined)).toBeNull();
+    expect(bolt11Msat("lnbc1pvjluezqqq")).toBeNull(); // no amount digits
+    expect(bolt11Msat("lnbc25p1qqq")).toBeNull(); // 2.5 msat — sub-msat
+    expect(bolt11Msat("lntb10u1qqq")).toBeNull(); // testnet
+    expect(bolt11Msat("lnbc99999991qqq")).toBeNull(); // 9,999,999 BTC > cap
+  });
+});
+
+describe("parseZapReceipt", () => {
+  it("accepts a fully consistent receipt", () => {
+    const parsed = parseZapReceipt(zapReceipt(), ALICE_PK);
+    expect(parsed).not.toBeNull();
+    expect(parsed?.address).toBe(ADDRESS);
+    expect(parsed?.dTag).toBe("hello-world");
+    expect(parsed?.authorPubkey).toBe(ALICE_PK);
+    expect(parsed?.senderPubkey).toBe(BOB_PK);
+    expect(parsed?.amountMsat).toBe(AMOUNT_MSAT);
+  });
+
+  it("rejects structural mismatches", () => {
+    const cases: [string, NostrEvent][] = [
+      ["receipt p is not the author", zapReceipt({ p: BOB_PK })],
+      ["receipt has no a tag", zapReceipt({ a: null })],
+      [
+        "a addresses another author",
+        zapReceipt({ a: `30023:${BOB_PK}:hello-world` }),
+      ],
+      ["a is not kind 30023", zapReceipt({ a: `1:${ALICE_PK}:x` })],
+      ["description is not JSON", zapReceipt({ description: "not json" })],
+      ["description is not a 9734", zapReceipt({ request: zapRequest({ kind: 1 }) })],
+      ["request p mismatch", zapReceipt({ request: zapRequest({ p: BOB_PK }) })],
+      [
+        "request a mismatch",
+        zapReceipt({ request: zapRequest({ a: `30023:${ALICE_PK}:other` }) }),
+      ],
+      [
+        "bolt11 disagrees with the request amount",
+        zapReceipt({ bolt11: "lnbc20u1qqq" }),
+      ],
+      ["missing bolt11", zapReceipt({ bolt11: null })],
+      [
+        "amount over the ceiling",
+        zapReceipt({
+          request: zapRequest({ amount: String(MAX_ZAP_MSAT * 10) }),
+        }),
+      ],
+    ];
+    for (const [label, ev] of cases) {
+      expect(parseZapReceipt(ev, ALICE_PK), label).toBeNull();
+    }
+  });
+
+  it("accepts a request WITHOUT an amount tag — the invoice is authoritative", () => {
+    // NIP-57 makes the 9734 amount optional; equality is only enforced when
+    // both exist. Wallets that omit it must still count.
+    const parsed = parseZapReceipt(
+      zapReceipt({ request: zapRequest({ amount: null }) }),
+      ALICE_PK,
+    );
+    expect(parsed?.amountMsat).toBe(AMOUNT_MSAT); // from the bolt11 HRP
+  });
+
+  it("rejects non-9735 kinds outright", () => {
+    const note = { ...zapReceipt(), kind: 1 };
+    expect(parseZapReceipt(note, ALICE_PK)).toBeNull();
+  });
+});