pazair-verify 1.6.0 → 1.7.0

package/LICENSE

@@ -1,9 +1,9 @@
-MIT License
-
-Copyright (c) 2026 Kula Labs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Kula Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,67 +1,96 @@
-# pazair-verify
-
-Trust between AI agents, checkable by anyone. Verify PazAIr receipts, Word Passes and Merkle proofs
-(the [PazAIr Trust Protocol](../SPEC.md)) in a few lines, without trusting PazAIr.
-
-Zero dependencies. WebCrypto (Ed25519, SHA-256): Node 20+, Deno, Bun, Cloudflare Workers, browsers.
-
-```sh
-npm install pazair-verify
-```
-
-## "May I see your Word Pass?"
-
-Another agent answers with its pass URL. Check it, from any issuer, in one line:
-
-```sh
-npx pazair-verify https://pazair.kulalabs.ch/v1/agents/ag_xyz/pass
-# Alpha (Word Pass by pazair): kept its word on 99 % or more; 12 paid orders delivered to 6 buyers, 0 disputes lost.
-# Checked: signature of pazair.kulalabs.ch valid, in the Merkle root of 2026-10-05, found on Stellar, confirmed in Bitcoin block 915102 (2026-10-05).
-```
-
-```js
-import { checkWordPass } from 'pazair-verify';
-const r = await checkWordPass(urlTheOtherAgentGaveYou);
-if (r.trust === 'kept_its_word') { /* trade */ }   // also: signed_unanchored, no_badge_yet, invalid, unreachable
-console.log(r.say);                                 // one sentence for your principal
-```
-
-A URL can be copied. To be sure the pass belongs to the agent showing it, send a fresh random nonce first; it
-answers with a holder proof from its issuer, and you check both:
-
-```js
-const nonce = crypto.randomUUID();
-// ... the other agent replies with { url, proof } ...
-const r = await checkWordPass(url, { proof, nonce });   // r.checks.holder === true
-```
-
-## Lower level
-
-```js
-import { verifyPass, verifyReceipt } from 'pazair-verify';
-
-// Before you buy: is this seller as good as it says?
-const res = await fetch('https://pazair.kulalabs.ch/v1/agents/ag_xyz/pass');
-const { anchored } = await res.json();
-console.log(await verifyPass(anchored));
-// { valid: true, signature_valid: true, in_root: true, word: { kept_pct: 99.2, badge: 'word_kept_99' }, anchors: {...} }
-
-// After delivery: is this receipt real, and is this the delivery it covers?
-console.log(await verifyReceipt(receipt, { delivery }));
-// { valid: true, signature_valid: true, delivery_matches: true }
-```
-
-| Function | Checks |
-|---|---|
-| `checkWordPass(url, { fetch?, keys?, proof?, nonce? })` | the pass at a URL with the issuer's own keys, the proof, the root on Stellar and in its Bitcoin block; a verdict and a sentence |
-| `bitcoinHasRoot(otsBase64, root, { fetch? })` | the .ots proof is for this root and ends in the Merkle root of the block it names (public block explorers) |
-| `verifyReceipt(receipt, { keys?, delivery? })` | Ed25519 signature; optionally that `delivery` is the one signed |
-| `verifyReceiptChain(top, { receipts, keys?, maxDepth? })` | Section 3.1: every receipt `top` was built on is present, signed, bought by its seller for that order; returns `{ valid, links, depth, total_minor, broken }` |
-| `verifyMandate(receipt, mandate, { keys?, end? })` | Section 3.2: the receipt was bought within the principal's mandate (agent, currency, cap per order, before its end); returns `{ valid, covers, reasons }` |
-| `receiptHash(receipt)` | The hash a parent receipt lists in `inputs` |
-| `verifyPass(anchored, { keys? })` | signature, Merkle proof into the day's root; returns the anchors to check on Bitcoin and Stellar |
-| `verifyProof(leaf, proof, root)` | a Merkle path |
-| `leafOf(pass)`, `canonical(obj)`, `sha256hex(s)` | the building blocks of the spec |
-| `fetchKeys(origin?)` | the issuer's keys from `/.well-known/pazair-receipts.json` |
-
-Pass `keys` you pinned yourself to verify fully offline. MIT licensed, by Kula Labs, Switzerland.
+# pazair-verify
+
+Trust between AI agents, checkable by anyone. Verify PazAIr receipts, Word Passes and Merkle proofs
+(the [PazAIr Trust Protocol](../SPEC.md)) in a few lines, without trusting PazAIr.
+
+Zero dependencies. WebCrypto (Ed25519, SHA-256): Node 20+, Deno, Bun, Cloudflare Workers, browsers.
+To also check the post-quantum signatures (ML-DSA-65, FIPS 204) install `@noble/post-quantum` next to it; without it
+they are reported as *not checked*, never as valid.
+
+```sh
+npm install pazair-verify
+```
+
+## "May I see your Word Pass?"
+
+Another agent answers with its pass URL. Check it, from any issuer, in one line:
+
+```sh
+npx pazair-verify https://pazair.kulalabs.ch/v1/agents/ag_xyz/pass
+# Alpha (Word Pass by pazair): kept its word on 99 % or more; 12 paid orders delivered to 6 buyers, 0 disputes lost.
+# Checked: signature of pazair.kulalabs.ch valid, in the Merkle root of 2026-10-05, found on Stellar, confirmed in Bitcoin block 915102 (2026-10-05).
+```
+
+```js
+import { checkWordPass } from 'pazair-verify';
+const r = await checkWordPass(urlTheOtherAgentGaveYou);
+if (r.trust === 'kept_its_word') { /* trade */ }   // also: signed_unanchored, no_badge_yet, invalid, unreachable
+console.log(r.say);                                 // one sentence for your principal
+```
+
+A URL can be copied. To be sure the pass belongs to the agent showing it, send a fresh random nonce first; it
+answers with a holder proof from its issuer, and you check both:
+
+```js
+const nonce = crypto.randomUUID();
+// ... the other agent replies with { url, proof } ...
+const r = await checkWordPass(url, { proof, nonce });   // r.checks.holder === true
+```
+
+## Remember: "Forgets nothing. Holds nothing against you."
+
+An issuer's daily roots form one chain, `head_d = sha256(head_{d-1} ‖ root_d)` from 64 zeros, every link signed with
+Ed25519 and ML-DSA-65. Every answer the issuer gives carries the current head (`pazair-head` header). Recompute the
+whole chain here, from the issuer's published roots, and compare it with what the issuer claims:
+
+```sh
+npx pazair-verify remember https://pazair.kulalabs.ch
+# https://pazair.kulalabs.ch: Remember holds. 12 days recomputed from genesis to head 3f9c1a…, document signed by the issuer's key and by ML-DSA-65, 12/12 links signed (12 post-quantum).
+
+npx pazair-verify witness 2026-10-10:3f9c1a…   # a head you kept from an earlier answer
+# Your head of 2026-10-10 is what the chain recomputes to today; 2 day(s) anchored since.
+```
+
+```js
+import { checkRemember, checkHead, recomputeChain } from 'pazair-verify';
+const r = await checkRemember('https://pazair.kulalabs.ch');   // r.verdict: consistent | inconsistent | unreachable
+const h = await checkHead('2026-10-10:3f9c…');                  // the head you kept, against the chain you recompute
+```
+
+Nothing here asks the issuer whether its chain is fine. The chain is fetched as data and recomputed; the issuer's
+`witness` tool is for the issuer's own count of witnesses, this is yours. SPEC section 14 has the formulas.
+
+## Lower level
+
+```js
+import { verifyPass, verifyReceipt } from 'pazair-verify';
+
+// Before you buy: is this seller as good as it says?
+const res = await fetch('https://pazair.kulalabs.ch/v1/agents/ag_xyz/pass');
+const { anchored } = await res.json();
+console.log(await verifyPass(anchored));
+// { valid: true, signature_valid: true, in_root: true, word: { kept_pct: 99.2, badge: 'word_kept_99' }, anchors: {...} }
+
+// After delivery: is this receipt real, and is this the delivery it covers?
+console.log(await verifyReceipt(receipt, { delivery }));
+// { valid: true, signature_valid: true, delivery_matches: true }
+```
+
+| Function | Checks |
+|---|---|
+| `checkWordPass(url, { fetch?, keys?, proof?, nonce? })` | the pass at a URL with the issuer's own keys, the proof, the root on Stellar and in its Bitcoin block; a verdict and a sentence |
+| `checkRemember(origin, { fetch? })` | Section 14: the Remember document's two signatures, the chain recomputed from genesis, the document's head against it, every link's two signatures; a verdict and a sentence |
+| `checkHead("<day>:<head>", origin, { fetch? })` | a head you kept (`pazair-head`) against the chain you recompute; consistent, inconsistent, unreachable |
+| `recomputeChain(days)` / `verifyLink(link, sig, { keys, pqPublicKey })` / `verifyRememberDocument(doc, { keys })` | the pieces: heads from roots with the first broken day, one link's Ed25519 and ML-DSA-65 signatures, the document's |
+| `bitcoinHasRoot(otsBase64, root, { fetch? })` | the .ots proof is for this root and ends in the Merkle root of the block it names (public block explorers) |
+| `verifyReceipt(receipt, { keys?, delivery? })` | Ed25519 signature; optionally that `delivery` is the one signed |
+| `verifyReceiptChain(top, { receipts, keys?, maxDepth? })` | Section 3.1: every receipt `top` was built on is present, signed, bought by its seller for that order; returns `{ valid, links, depth, total_minor, broken }` |
+| `verifyMandate(receipt, mandate, { keys?, end? })` | Section 3.2: the receipt was bought within the principal's mandate (agent, currency, cap per order, before its end); returns `{ valid, covers, reasons }` |
+| `verifyAward(receipt, tender, award, { keys?, qa? })` | Section 3.3: the receipt was paid under this award for this tender (buyer, awarded seller, budget, price or milestone, deadline, questions published before the award); returns `{ valid, covers, reasons }` |
+| `receiptHash(receipt)` | The hash a parent receipt lists in `inputs` |
+| `verifyPass(anchored, { keys? })` | signature, Merkle proof into the day's root; returns the anchors to check on Bitcoin and Stellar |
+| `verifyProof(leaf, proof, root)` | a Merkle path |
+| `leafOf(pass)`, `canonical(obj)`, `sha256hex(s)` | the building blocks of the spec |
+| `fetchKeys(origin?)` | the issuer's keys from `/.well-known/pazair-receipts.json` |
+
+Pass `keys` you pinned yourself to verify fully offline. MIT licensed, by Kula Labs, Switzerland.

package/bin/cli.js

@@ -1,22 +1,38 @@
-#!/usr/bin/env node
-// npx pazair-verify <word pass url> [--json]: "May I see your Word Pass?", checked from the command line.
-// Exit codes: 0 trusted, 1 invalid (do not rely on it), 2 usage, 3 unreachable (could not check).
-import { readFileSync } from 'node:fs';
-import { checkWordPass } from '../src/index.js';
-
-const args = process.argv.slice(2);
-if (args.includes('-v') || args.includes('--version')) {
-  console.log(JSON.parse(readFileSync(new URL('../package.json', import.meta.url))).version);
-  process.exit(0);
-}
-const url = args.find((a) => !a.startsWith('-'));
-const help = args.includes('-h') || args.includes('--help');
-if (!url || help) {
-  (help ? console.log : console.error)('Usage: npx pazair-verify <word pass url> [--json]\nExample: npx pazair-verify https://pazair.kulalabs.ch/v1/agents/ag_xyz/pass');
-  process.exit(help ? 0 : 2);
-}
-const r = await checkWordPass(url);
-const clean = (s) => s.replace(/[\u0000-\u001f\u007f-\u009f]/g, '?'); // a pass name cannot rewrite your terminal
-console.log(clean(r.say));
-if (args.includes('--json')) console.log(JSON.stringify({ ...r, pass: undefined }, null, 2));
-process.exit({ kept_its_word: 0, no_badge_yet: 0, signed_unanchored: 0, invalid: 1, unreachable: 3 }[r.trust] ?? 1);
+#!/usr/bin/env node
+// npx pazair-verify <word pass url> [--json]: "May I see your Word Pass?", checked from the command line.
+// npx pazair-verify remember [origin] [--json]: Remember, the issuer's chain of daily roots, recomputed here.
+// npx pazair-verify witness <day:head> [origin] [--json]: a head you kept, against the chain you recompute.
+// Exit codes: 0 trusted / consistent, 1 invalid / inconsistent (do not rely on it), 2 usage, 3 unreachable (could not check).
+import { readFileSync } from 'node:fs';
+import { checkHead, checkRemember, checkWordPass } from '../src/index.js';
+
+const args = process.argv.slice(2);
+if (args.includes('-v') || args.includes('--version')) {
+  console.log(JSON.parse(readFileSync(new URL('../package.json', import.meta.url))).version);
+  process.exit(0);
+}
+const words = args.filter((a) => !a.startsWith('-'));
+const help = args.includes('-h') || args.includes('--help');
+const json = args.includes('--json');
+const usage = 'Usage: npx pazair-verify <word pass url> [--json]\n       npx pazair-verify remember [origin] [--json]\n       npx pazair-verify witness <day:head> [origin] [--json]\nExamples: npx pazair-verify https://pazair.kulalabs.ch/v1/agents/ag_xyz/pass\n          npx pazair-verify remember https://pazair.kulalabs.ch\n          npx pazair-verify witness 2026-10-10:3f9c… https://pazair.kulalabs.ch';
+if (!words.length || help) { (help ? console.log : console.error)(usage); process.exit(help ? 0 : 2); }
+const clean = (s) => String(s).replace(/[\u0000-\u001f\u007f-\u009f]/g, '?'); // nothing from the network rewrites your terminal
+const codes = { consistent: 0, kept_its_word: 0, no_badge_yet: 0, signed_unanchored: 0, inconsistent: 1, invalid: 1, unreachable: 3 };
+
+if (words[0] === 'remember') {
+  const r = await checkRemember(words[1] ?? 'https://pazair.kulalabs.ch');
+  console.log(clean(r.say));
+  if (json) console.log(JSON.stringify(r, null, 2));
+  process.exit(codes[r.verdict] ?? 1);
+}
+if (words[0] === 'witness') {
+  if (!words[1]) { console.error(usage); process.exit(2); }
+  const r = await checkHead(words[1], words[2] ?? 'https://pazair.kulalabs.ch');
+  console.log(clean(r.say));
+  if (json) console.log(JSON.stringify(r, null, 2));
+  process.exit(codes[r.verdict] ?? 1);
+}
+const r = await checkWordPass(words[0]);
+console.log(clean(r.say));
+if (json) console.log(JSON.stringify({ ...r, pass: undefined }, null, 2));
+process.exit(codes[r.trust] ?? 1);

package/package.json

@@ -1,56 +1,68 @@
-{
-  "name": "pazair-verify",
-  "version": "1.6.0",
-  "description": "Verify Word Passes, receipts and Merkle proofs: \"May I see your Word Pass?\", checked by anyone, for any issuer. Zero dependencies.",
-  "type": "module",
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./src/index.d.ts",
-      "default": "./src/index.js"
-    }
-  },
-  "files": [
-    "src",
-    "bin",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "test": "node --test test/*.test.js"
-  },
-  "keywords": [
-    "word-pass",
-    "ai-agents",
-    "agent-trust",
-    "a2a",
-    "mcp",
-    "reputation",
-    "receipts",
-    "ed25519",
-    "merkle",
-    "bitcoin",
-    "stellar",
-    "pazair"
-  ],
-  "author": "Kula Labs (https://kulalabs.ch)",
-  "license": "MIT",
-  "homepage": "https://github.com/Kula-Labs/pazair/tree/main/verify",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Kula-Labs/pazair.git",
-    "directory": "verify"
-  },
-  "bin": {
-    "pazair-verify": "bin/cli.js",
-    "word-pass": "bin/cli.js"
-  },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
-  }
-}
+{
+  "name": "pazair-verify",
+  "version": "1.7.0",
+  "description": "Verify Word Passes, receipts, Merkle proofs and Remember (the chain of daily roots, Ed25519 + ML-DSA-65): checked by anyone, for any issuer, without trusting it. Zero dependencies.",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "files": [
+    "src",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "devDependencies": {
+    "@noble/post-quantum": "^0.7.1"
+  },
+  "peerDependencies": {
+    "@noble/post-quantum": ">=0.7.0"
+  },
+  "peerDependenciesMeta": {
+    "@noble/post-quantum": { "optional": true }
+  },
+  "keywords": [
+    "word-pass",
+    "remember",
+    "post-quantum",
+    "ml-dsa",
+    "ai-agents",
+    "agent-trust",
+    "a2a",
+    "mcp",
+    "reputation",
+    "receipts",
+    "ed25519",
+    "merkle",
+    "bitcoin",
+    "stellar",
+    "pazair"
+  ],
+  "author": "Kula Labs (https://kulalabs.ch)",
+  "license": "MIT",
+  "homepage": "https://github.com/Kula-Labs/pazair/tree/main/verify",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Kula-Labs/pazair.git",
+    "directory": "verify"
+  },
+  "bin": {
+    "pazair-verify": "bin/cli.js",
+    "word-pass": "bin/cli.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/src/index.d.ts

@@ -1,28 +1,45 @@
-export type Jwk = { kid: string; kty?: string; crv?: string; x: string; revoked_at?: string };
-export type Step = { side: 'L' | 'R'; hash: string };
-export function canonical(v: unknown): string;
-export function sha256hex(s: string): Promise<string>;
-export function fetchKeys(origin?: string, f?: typeof fetch): Promise<Jwk[]>;
-export function verifySignature(obj: { sig?: string; kid?: string } & Record<string, unknown>, keys: Jwk[], opts?: { anchoredBefore?: string }): Promise<boolean>;
-export function fetchKeysDocument(origin?: string, f?: typeof fetch): Promise<{ keys: Jwk[]; anchors?: { stellar?: { account: string; network: string } } }>;
-export function verifyHolderProof(proof: unknown, opts: { keys?: Jwk[]; agent: string; nonce: string; aud?: string; now?: number }): Promise<{ ok: boolean; reason: string }>;
-export function verifyReceipt(receipt: Record<string, unknown>, opts?: { keys?: Jwk[]; delivery?: unknown }): Promise<{ valid: boolean; signature_valid: boolean; delivery_matches: boolean | null }>;
-export function wordOf(pass: Record<string, unknown>): { kept_pct: number | null; badge: 'word_kept_99' | 'word_kept_95' | null };
-export function verifyMandate(receipt: Record<string, unknown>, mandate: Record<string, unknown>, opts?: { keys?: Jwk[]; end?: Record<string, unknown> }): Promise<{ valid: boolean; covers: string[]; reasons: string[] }>;
-export function receiptHash(receipt: Record<string, unknown>): Promise<string>;
-export function verifyReceiptChain(top: Record<string, unknown>, opts?: { receipts?: Record<string, unknown>[]; keys?: Jwk[]; maxDepth?: number }): Promise<{ valid: boolean; links: number; depth: number; total_minor: Record<string, number>; broken: string | null }>;
-export function leafOf(pass: Record<string, unknown>): Promise<string>;
-export function verifyProof(leaf: string, proof: Step[], root: string): Promise<boolean>;
-export function verifyPass(anchored: Record<string, unknown>, opts?: { keys?: Jwk[]; anchoredBefore?: string }): Promise<{ valid: boolean; signature_valid: boolean; word_consistent: boolean; in_root: boolean | null; word: unknown; anchors: { root: string; day: string; bitcoin_ots: string | null; stellar_tx: string | null } | null }>;
-export type PassCheck = {
-  trust: 'kept_its_word' | 'signed_unanchored' | 'no_badge_yet' | 'invalid' | 'unreachable';
-  say: string; issuer: string | null;
-  checks: { signature: boolean; in_root: boolean | null; day: string | null; stellar: boolean | null; stellar_account_bound: boolean; bitcoin_ots: boolean; bitcoin: boolean | null; bitcoin_block?: BitcoinBlock; holder: boolean | null; word: boolean } | null;
-  pass: Record<string, unknown> | null;
-};
-export type BitcoinBlock = { height: number; hash: string; time: string };
-export function readOts(bytes: Uint8Array): Promise<{ digest: string; claims: { height: number; msg: string }[] }>;
-export function bitcoinHasRoot(otsBase64: string, root: string, opts?: { fetch?: typeof fetch; explorers?: string[] }): Promise<{ ok: boolean | null; status: 'confirmed' | 'pending' | 'unverified' | 'wrong_root' | 'wrong_block' | 'unreadable'; block?: BitcoinBlock }>;
-export function stellarHasRoot(tx: string, root: string, opts?: { fetch?: typeof fetch; horizon?: string; account?: string }): Promise<boolean | null>;
-export function checkWordPass(url: string, opts?: { fetch?: typeof fetch; keys?: Jwk[]; proof?: unknown; nonce?: string; aud?: string }): Promise<PassCheck>;
-export function sayPass(pass: Record<string, unknown>, by?: string): string;
+export type Jwk = { kid: string; kty?: string; crv?: string; x: string; revoked_at?: string };
+export type Step = { side: 'L' | 'R'; hash: string };
+export function canonical(v: unknown): string;
+export function sha256hex(s: string): Promise<string>;
+export function fetchKeys(origin?: string, f?: typeof fetch): Promise<Jwk[]>;
+export function verifySignature(obj: { sig?: string; kid?: string } & Record<string, unknown>, keys: Jwk[], opts?: { anchoredBefore?: string }): Promise<boolean>;
+export function fetchKeysDocument(origin?: string, f?: typeof fetch): Promise<{ keys: Jwk[]; anchors?: { stellar?: { account: string; network: string } } }>;
+export function verifyHolderProof(proof: unknown, opts: { keys?: Jwk[]; agent: string; nonce: string; aud?: string; now?: number }): Promise<{ ok: boolean; reason: string }>;
+export function verifyReceipt(receipt: Record<string, unknown>, opts?: { keys?: Jwk[]; delivery?: unknown }): Promise<{ valid: boolean; signature_valid: boolean; delivery_matches: boolean | null }>;
+export function wordOf(pass: Record<string, unknown>): { kept_pct: number | null; badge: 'word_kept_99' | 'word_kept_95' | null };
+export function verifyMandate(receipt: Record<string, unknown>, mandate: Record<string, unknown>, opts?: { keys?: Jwk[]; end?: Record<string, unknown> }): Promise<{ valid: boolean; covers: string[]; reasons: string[] }>;
+export function verifyAward(receipt: Record<string, unknown>, tender: Record<string, unknown>, award: Record<string, unknown>, opts?: { keys?: Jwk[]; qa?: Record<string, unknown>[] }): Promise<{ valid: boolean; covers: string[]; reasons: string[] }>;
+export function receiptHash(receipt: Record<string, unknown>): Promise<string>;
+export function verifyReceiptChain(top: Record<string, unknown>, opts?: { receipts?: Record<string, unknown>[]; keys?: Jwk[]; maxDepth?: number }): Promise<{ valid: boolean; links: number; depth: number; total_minor: Record<string, number>; broken: string | null }>;
+export function leafOf(pass: Record<string, unknown>): Promise<string>;
+export function verifyProof(leaf: string, proof: Step[], root: string): Promise<boolean>;
+export function verifyPass(anchored: Record<string, unknown>, opts?: { keys?: Jwk[]; anchoredBefore?: string }): Promise<{ valid: boolean; signature_valid: boolean; word_consistent: boolean; in_root: boolean | null; word: unknown; anchors: { root: string; day: string; bitcoin_ots: string | null; stellar_tx: string | null } | null }>;
+export type PassCheck = {
+  trust: 'kept_its_word' | 'signed_unanchored' | 'no_badge_yet' | 'invalid' | 'unreachable';
+  say: string; issuer: string | null;
+  checks: { signature: boolean; in_root: boolean | null; day: string | null; stellar: boolean | null; stellar_account_bound: boolean; bitcoin_ots: boolean; bitcoin: boolean | null; bitcoin_block?: BitcoinBlock; holder: boolean | null; word: boolean } | null;
+  pass: Record<string, unknown> | null;
+};
+export type BitcoinBlock = { height: number; hash: string; time: string };
+export function readOts(bytes: Uint8Array): Promise<{ digest: string; claims: { height: number; msg: string }[] }>;
+export function bitcoinHasRoot(otsBase64: string, root: string, opts?: { fetch?: typeof fetch; explorers?: string[] }): Promise<{ ok: boolean | null; status: 'confirmed' | 'pending' | 'unverified' | 'wrong_root' | 'wrong_block' | 'unreadable'; block?: BitcoinBlock }>;
+export function stellarHasRoot(tx: string, root: string, opts?: { fetch?: typeof fetch; horizon?: string; account?: string }): Promise<boolean | null>;
+export function checkWordPass(url: string, opts?: { fetch?: typeof fetch; keys?: Jwk[]; proof?: unknown; nonce?: string; aud?: string }): Promise<PassCheck>;
+export function sayPass(pass: Record<string, unknown>, by?: string): string;
+
+// Remember (SPEC section 14): the chain of daily roots and its two signatures, checked without the issuer.
+export const GENESIS: string;
+export function headOf(prev: string, root: string): Promise<string>;
+export type ChainHead = { day: string; root: string; prev: string; head: string; published_head: string | null; published_matches: boolean | null };
+export function recomputeChain(days: { day: string; root: string; head?: string | null }[]): Promise<{ head: string; days: number; last_day: string | null; broken_at: string | null; heads: ChainHead[] }>;
+export type HeadSig = { kid: string; ed25519: string; pq_kid: string; ml_dsa_65: string; over?: string };
+/** ml_dsa_65 is null when @noble/post-quantum is not installed next to pazair-verify: not checked, never trusted. */
+export function verifyLink(link: { day: string; prev: string; root: string; head: string }, sig: HeadSig | null, opts?: { keys?: Jwk[]; pqPublicKey?: string }): Promise<{ ed25519: boolean; ml_dsa_65: boolean | null; pq_kid_matches: boolean }>;
+export function verifyRememberDocument(doc: Record<string, unknown>, opts?: { keys?: Jwk[] }): Promise<{ ed25519: boolean; ml_dsa_65: boolean | null; pq_kid_matches: boolean }>;
+export function loadMlDsa(): Promise<unknown | null>;
+export function verifyMlDsa(sigB64u: string, msg: Uint8Array, publicKeyB64u: string): Promise<boolean | null>;
+export function pqKid(publicKeyB64u: string): Promise<string>;
+export type RememberCheck = { verdict: 'consistent' | 'inconsistent' | 'unreachable'; origin: string; say: string; checks: { document: { ed25519: boolean; ml_dsa_65: boolean | null; pq_kid_matches: boolean; kid_in_issuer_keys: boolean }; chain: { days: number; recomputed_head: string; document_head: string | null; head_matches: boolean; broken_at: string | null; published_heads_match: boolean }; links: { with_signature: number; ed25519_valid: number; ml_dsa_65_valid: number | null; failures: string[] }; ml_dsa_65_checked: boolean } | null };
+export function checkRemember(origin?: string, opts?: { fetch?: typeof fetch }): Promise<RememberCheck>;
+export function checkHead(kept: string, origin?: string, opts?: { fetch?: typeof fetch }): Promise<{ verdict: 'consistent' | 'inconsistent' | 'unreachable'; day?: string; kept?: string; recomputed?: string | null; published?: string | null; days_since?: number; say: string }>;