capacity-attest 0.4.0 → 0.5.0

package/README.md

@@ -74,6 +74,12 @@ Eerlijke grens: ook zelf-herrekenen betrapt geen verborgen laatste claim en geen
 
 Een openbaar, zelf-controleerbaar voorbeeld met een nagebootste verbergende host en expres-kapotte testgevallen staat in [docs/COMPLETENESS-FIXTURE.md](./docs/COMPLETENESS-FIXTURE.md). Draai het met `npm run fixture`; dezelfde controles draaien bij elke push als test. Zo kun je onze claim zelf natellen in plaats van ons op ons woord te geloven.
 
+## Claims van andere installaties vinden (D-005)
+
+`get_delivery_history` is per definitie lokaal: koper B ziet niet wat koper A op een andere installatie vastlegde over dezelfde verkoper. Omdat elke claim zelf-verifieerbaar is, heeft vindbaarheid geen vertrouwde index nodig. `discoverDeliveryHistory(seller, sources)` (zie `src/discovery.ts`) leest een verkopers claims uit meerdere onafhankelijke, ONvertrouwde bronnen (je lokale ledger plus elk host-onafhankelijk substraat dat je wilt lezen), ontdubbelt, herverifieert elke claim, filtert andere verkopers eruit, en draait de completeness-check over het geheel. Een bron die nep injecteert wordt geweigerd; een bron die weglaat is het D-006-probleem, meegenomen maar niet magisch opgelost.
+
+De productie-onderlaag (EAS op Base, ERC-8004) is bewust nog niet live gekoppeld: dat kost gas en wacht op een echte integrator. De naad staat klaar. Een openbaar, draaibaar voorbeeld met twee nagebootste installaties staat in [docs/DISCOVERY-FIXTURE.md](./docs/DISCOVERY-FIXTURE.md), draai het met `npm run discovery-fixture`. Zie [DECISIONS.md](./DECISIONS.md) D-005.
+
 ### 3. `resolve_agent_identity` *(sinds 0.3.0)*
 
 Read-only opzoeking tegen een ERC-8004 Identity Registry: wie bezit `agentId` (`ownerOf`) en waar staat zijn registratiebestand (`tokenURI`). Alleen de standaard ERC-721-interface wordt aangeroepen, niets ERC-8004-specifieks. Vereist van de aanroeper zowel `agentRegistryRef` (`"eip155:<chainId>:<registryAddress>"`) als een `rpcUrl` voor die chain: dit project bundelt bewust geen eigen RPC-provider en geen canoniek registry-adres, want ERC-8004 heeft onafhankelijke deployments per chain en de EIP-tekst zelf noemt geen vast adres. Haalt bewust NOOIT op wat `tokenURI` aanwijst (dat blijft een pointer die de aanroeper zelf desgewenst opvraagt); dat zou een SSRF-vormig risico zijn op aanroeper-gecontroleerde on-chain data.
@@ -89,7 +95,7 @@ De claim wordt ondertekend door de **koper** (de partij die betaalde en dus weet
 Elke claim in de ledger is met alleen het npm-package en de rauwe claim-bytes na te rekenen, zonder toegang tot dit project of een netwerkoproep naar ons. Geen account, geen hosted call.
 
 ```bash
-npm install capacity-attest@0.2.0
+npm install capacity-attest
 ```
 
 ```js

package/dist/discovery-fixture.d.ts

@@ -0,0 +1,26 @@
+import { ethers } from "ethers";
+import { type DeliveryClaim } from "./schema.js";
+export declare const BUYER_A: ethers.Wallet;
+export declare const BUYER_B: ethers.Wallet;
+export declare const SELLER_X = "0x00000000000000000000000000000000000000aa";
+export interface DiscoveryFixture {
+    a1: DeliveryClaim;
+    a2: DeliveryClaim;
+    a3: DeliveryClaim;
+    b1: DeliveryClaim;
+    y1: DeliveryClaim;
+    forged: DeliveryClaim;
+    tampered: DeliveryClaim;
+}
+export declare function buildDiscoveryFixture(): Promise<DiscoveryFixture>;
+export type ControlKind = "GREEN" | "RED";
+export interface Control {
+    id: string;
+    kind: ControlKind;
+    what: string;
+    expected: string;
+    actual: string;
+    pass: boolean;
+}
+export declare function runControls(): Promise<Control[]>;
+//# sourceMappingURL=discovery-fixture.d.ts.map

package/dist/discovery-fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery-fixture.d.ts","sourceRoot":"","sources":["../src/discovery-fixture.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAKpE,eAAO,MAAM,OAAO,eAA4C,CAAC;AACjE,eAAO,MAAM,OAAO,eAA4C,CAAC;AAGjE,eAAO,MAAM,QAAQ,+CAA+C,CAAC;AASrE,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,aAAa,CAAC;IAClB,EAAE,EAAE,aAAa,CAAC;IAClB,EAAE,EAAE,aAAa,CAAC;IAClB,EAAE,EAAE,aAAa,CAAC;IAClB,EAAE,EAAE,aAAa,CAAC;IAClB,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,EAAE,aAAa,CAAC;CACzB;AAED,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAkBvE;AAED,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,KAAK,CAAC;AAC1C,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf;AASD,wBAAsB,WAAW,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CA2CtD"}

package/dist/discovery-fixture.js

@@ -0,0 +1,95 @@
+// discovery-fixture.ts — a public, reproducible fixture for cross-installation
+// discovery (D-005), the companion to completeness-fixture.ts (D-006).
+//
+// It demonstrates, with claims you can rebuild from fixed test keys, that:
+//   1. The gap is real: buyer B, reading only B's own installation, does not
+//      see buyer A's claims about the same seller.
+//   2. Discovery closes it: aggregating B's local ledger with a shared,
+//      UNTRUSTED substrate (simulated here, EAS/ERC-8004 in production) makes
+//      A's claims visible to B, and every one is re-verified locally.
+//   3. It stays trustless: a malicious source's forged/tampered claims are
+//      rejected, and claims about a different seller are filtered out.
+//   4. It composes with D-006: a source that hides a MIDDLE claim in a chain
+//      it otherwise reveals is still caught by the completeness analysis, now
+//      across installations.
+//
+// Honest boundary, same as everywhere else: discovery is bounded by what
+// sources reveal. It solves findability, not completeness. A source that omits
+// a claim (a hidden tail, or a whole buyer) cannot be forced to reveal it; no
+// aggregation invents what no source shows.
+//
+// Pure, offline, deterministic: fixed keys, fixed timestamps, no ledger, no
+// network. Consumed by examples/discovery-fixture.ts and the discovery tests.
+import { ethers } from "ethers";
+import { signClaim } from "./signing.js";
+import { discoverDeliveryHistory, staticSource } from "./discovery.js";
+// Two fixed TEST buyers on two notional installations, and one impostor.
+// source: simulated (deterministic keys, not real identities).
+export const BUYER_A = new ethers.Wallet("0x" + "a1".repeat(32));
+export const BUYER_B = new ethers.Wallet("0x" + "b2".repeat(32));
+const IMPOSTOR = new ethers.Wallet("0x" + "cc".repeat(32));
+export const SELLER_X = "0x00000000000000000000000000000000000000aa";
+const SELLER_Y = "0x00000000000000000000000000000000000000bb"; // a different seller, for the filter control
+const EVIDENCE_HASH = "a".repeat(64);
+async function sign(wallet, content) {
+    const { claimId, signature } = await signClaim(wallet, content);
+    return { ...content, claimId, signature };
+}
+export async function buildDiscoveryFixture() {
+    const aBase = { sellerAddress: SELLER_X, buyerAddress: BUYER_A.address, assetType: "gpu-hours", evidenceHash: EVIDENCE_HASH };
+    const a1 = await sign(BUYER_A, { ...aBase, promisedSpec: "1x A100, 4h", delivered: "yes", settlementRef: "0x" + "a1".repeat(32), timestamp: "2026-01-01T00:00:00.000Z" });
+    const a2 = await sign(BUYER_A, { ...aBase, promisedSpec: "1x A100, 8h", delivered: "no", settlementRef: "0x" + "a2".repeat(32), timestamp: "2026-02-01T00:00:00.000Z", priorClaimId: a1.claimId });
+    const a3 = await sign(BUYER_A, { ...aBase, promisedSpec: "1x A100, 2h", delivered: "yes", settlementRef: "0x" + "a3".repeat(32), timestamp: "2026-03-01T00:00:00.000Z", priorClaimId: a2.claimId });
+    const b1 = await sign(BUYER_B, { sellerAddress: SELLER_X, buyerAddress: BUYER_B.address, assetType: "gpu-hours", promisedSpec: "1x A100, 1h", delivered: "yes", evidenceHash: EVIDENCE_HASH, settlementRef: "0x" + "b1".repeat(32), timestamp: "2026-02-15T00:00:00.000Z" });
+    const y1 = await sign(BUYER_A, { sellerAddress: SELLER_Y, buyerAddress: BUYER_A.address, assetType: "gpu-hours", promisedSpec: "other seller", delivered: "yes", evidenceHash: EVIDENCE_HASH, settlementRef: "0x" + "01".repeat(32), timestamp: "2026-01-15T00:00:00.000Z" });
+    // forged: content claims buyerAddress = A, but signed by the impostor, so the
+    // signature does not recover to A. verifyClaim must reject it.
+    const forgedContent = { sellerAddress: SELLER_X, buyerAddress: BUYER_A.address, assetType: "gpu-hours", promisedSpec: "forged", delivered: "yes", evidenceHash: EVIDENCE_HASH, settlementRef: "0x" + "de".repeat(32), timestamp: "2026-04-01T00:00:00.000Z" };
+    const forgedSig = await signClaim(IMPOSTOR, forgedContent);
+    const forged = { ...forgedContent, ...forgedSig };
+    // tampered: take a genuine a1 and flip delivered without recomputing claimId.
+    const tampered = { ...a1, delivered: "no" };
+    return { a1, a2, a3, b1, y1, forged, tampered };
+}
+function control(id, kind, what, expected, actual) {
+    return { id, kind, what, expected, actual, pass: expected === actual };
+}
+function has(result, claim) {
+    return result.claims.some((c) => c.claimId.toLowerCase() === claim.claimId.toLowerCase());
+}
+export async function runControls() {
+    const { a1, a2, a3, b1, y1, forged, tampered } = await buildDiscoveryFixture();
+    const controls = [];
+    // D1 GREEN — the gap: B, reading only its own installation, does not see A's negative claim.
+    const bOnly = await discoverDeliveryHistory(SELLER_X, [staticSource("installation-B-local", [b1])]);
+    controls.push(control("D1", "GREEN", "B's own installation alone does NOT contain A's negative claim (the D-005 gap)", "a2 absent, count=1", `a2 ${has(bOnly, a2) ? "present" : "absent"}, count=${bOnly.count}`));
+    // D2 GREEN — findability: B + shared substrate surfaces A's claims to B. The
+    // substrate is a RAW source (does not pre-filter by seller) that also carries
+    // a Y-seller claim, so discovery's OWN seller filter is what must drop y1.
+    const substrate = { name: "shared-substrate (simulated EAS/ERC-8004)", fetchForSeller: async () => [a1, a2, a3, y1] };
+    const discovered = await discoverDeliveryHistory(SELLER_X, [staticSource("installation-B-local", [b1]), substrate]);
+    controls.push(control("D2", "GREEN", "Discovery surfaces A's negative claim to B across installations", "a2 present, count=4", `a2 ${has(discovered, a2) ? "present" : "absent"}, count=${discovered.count}`));
+    // D3 GREEN — every claim in the aggregate is verified.
+    const { verifyClaim } = await import("./signing.js");
+    const allVerify = discovered.claims.every((c) => verifyClaim(c).ok);
+    controls.push(control("D3", "GREEN", "Every claim in the aggregate re-verifies locally", "true", String(allVerify)));
+    // D4 GREEN — a claim about a different seller (y1) is filtered out of X's aggregate.
+    controls.push(control("D4", "GREEN", "A different-seller claim from a source is filtered out", "y1 absent", `y1 ${has(discovered, y1) ? "present" : "absent"}`));
+    // D5 GREEN — dedup: the same claim from two sources is counted once.
+    const deduped = await discoverDeliveryHistory(SELLER_X, [staticSource("src1", [b1, a1]), staticSource("src2", [b1, a1])]);
+    const src2 = deduped.sources[1];
+    controls.push(control("D5", "GREEN", "The same claim from two sources is counted once", "count=2, dup=2", `count=${deduped.count}, dup=${src2?.duplicates}`));
+    // D6 RED — a forged claim (wrong signer) from a source is rejected, not surfaced.
+    const withForged = await discoverDeliveryHistory(SELLER_X, [staticSource("malicious", [forged])]);
+    controls.push(control("D6", "RED", "A forged claim (wrong signer) is rejected, not surfaced", "count=0, rejected>=1", `count=${withForged.count}, ${(withForged.sources[0]?.rejected ?? 0) >= 1 ? "rejected>=1" : "rejected=0"}`));
+    // D7 RED — a tampered claim (flipped byte, claimId not recomputed) is rejected.
+    const withTampered = await discoverDeliveryHistory(SELLER_X, [staticSource("malicious", [tampered])]);
+    controls.push(control("D7", "RED", "A tampered claim (flipped byte) is rejected, not surfaced", "count=0, rejected>=1", `count=${withTampered.count}, ${(withTampered.sources[0]?.rejected ?? 0) >= 1 ? "rejected>=1" : "rejected=0"}`));
+    // D8 GREEN — composition with D-006: a substrate that hides A's MIDDLE claim
+    // (shows a1 and a3, omits a2) is still caught, now across installations.
+    const hiding = await discoverDeliveryHistory(SELLER_X, [staticSource("installation-B-local", [b1]), staticSource("substrate-hiding-a2", [a1, a3])]);
+    const flaggedA2 = hiding.completeness.possibleOmissions.some((o) => o.missingPriorClaimId.toLowerCase() === a2.claimId.toLowerCase());
+    controls.push(control("D8", "GREEN", "A source hiding a middle claim is caught by completeness, across installations", "true", String(flaggedA2)));
+    return controls;
+}
+//# sourceMappingURL=discovery-fixture.js.map

package/dist/discovery-fixture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery-fixture.js","sourceRoot":"","sources":["../src/discovery-fixture.ts"],"names":[],"mappings":"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"}

package/dist/discovery.d.ts

@@ -0,0 +1,80 @@
+import { type DeliveryClaim } from "./schema.js";
+import { type CompletenessReport } from "./completeness.js";
+/**
+ * An untrusted place claims about a seller can be discovered: the local
+ * ledger, a shared file, an EAS query on Base, another installation's public
+ * endpoint, an IPFS/git convention, etc. `fetchForSeller` may return anything,
+ * including forged or junk claims; discoverDeliveryHistory re-verifies all of
+ * them, so a source is never trusted, only read.
+ */
+export interface ClaimSource {
+    /** Human label for per-source accounting in the result. */
+    name: string;
+    /** Return whatever this source believes are claims about sellerAddress. Untrusted. */
+    fetchForSeller(sellerAddress: string): Promise<DeliveryClaim[]>;
+}
+/** Per-source accounting: what a source returned, and how much survived verification. */
+export interface SourceReport {
+    name: string;
+    /** How many entries the source returned (before any cap). */
+    fetched: number;
+    /** How many verified, concerned this seller, AND were not already contributed by an earlier source. */
+    accepted: number;
+    /** How many FAILED verifyClaim (forged/tampered/junk). Cryptographic failures only. */
+    rejected: number;
+    /** How many verified fine but were about a DIFFERENT seller (honest-but-off-topic, not a forgery). */
+    wrongSeller: number;
+    /** How many verified but were duplicates of a claim already seen (same claimId). */
+    duplicates: number;
+    /** Set when the source returned more than the per-source cap; only the first cap entries were examined. */
+    truncated?: boolean;
+    /** Set only when fetchForSeller threw OR resolved to a non-array; the source is skipped, others still run. */
+    error?: string;
+}
+/** Optional per-call limits, mainly so tests can exercise the caps cheaply; production uses the defaults above. */
+export interface DiscoverOptions {
+    maxClaimsPerSource?: number;
+    maxTotalClaims?: number;
+}
+export interface AggregatedHistory {
+    sellerAddress: string;
+    /** Distinct, verified claims for this seller across all sources, oldest first. */
+    count: number;
+    claims: DeliveryClaim[];
+    /** Per-source contribution accounting. */
+    sources: SourceReport[];
+    /** Completeness analysis over the aggregated set (same meaning + limits as D-006). */
+    completeness: CompletenessReport;
+    /** Fixed, factual note about what aggregation does and does not guarantee. */
+    note: string;
+}
+/**
+ * Trustless cross-installation aggregation. Reads a seller's claims from every
+ * source, de-duplicates by claimId, re-verifies each one (dropping anything
+ * that fails), and runs completeness over the survivors. No source is trusted;
+ * a source that throws is recorded and skipped, never fatal.
+ *
+ * Order note: sources are processed in the order given, purely so per-source
+ * `accepted`/`duplicates` accounting is deterministic (the first source to
+ * carry a given claimId gets the `accepted` credit; later ones counting it as
+ * a duplicate). The final `claims` array is sorted by timestamp regardless of
+ * source order, so the aggregate itself does not depend on which source is
+ * listed first.
+ */
+export declare function discoverDeliveryHistory(sellerAddress: string, sources: ClaimSource[], opts?: DiscoverOptions): Promise<AggregatedHistory>;
+/**
+ * A source backed by THIS installation's local ledger. This is the one source
+ * that is already trusted in the sense that its own read path re-verifies, but
+ * discoverDeliveryHistory re-verifies it anyway (harmless, keeps the trust
+ * model uniform: no source is special).
+ */
+export declare function localLedgerSource(name?: string): ClaimSource;
+/**
+ * A source over a fixed, in-memory list of claims. Used to simulate a
+ * host-independent substrate (a shared file, an EAS query result, another
+ * installation's export) in tests and the discovery fixture, without a network
+ * or a chain. Deliberately does NO verification itself, so the aggregation's
+ * own verification is what the tests actually exercise.
+ */
+export declare function staticSource(name: string, claims: DeliveryClaim[]): ClaimSource;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"AAqCA,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAGtE,OAAO,EAAuB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AASjF;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,sFAAsF;IACtF,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;CACjE;AAED,yFAAyF;AACzF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;IAChB,uGAAuG;IACvG,QAAQ,EAAE,MAAM,CAAC;IACjB,uFAAuF;IACvF,QAAQ,EAAE,MAAM,CAAC;IACjB,sGAAsG;IACtG,WAAW,EAAE,MAAM,CAAC;IACpB,oFAAoF;IACpF,UAAU,EAAE,MAAM,CAAC;IACnB,2GAA2G;IAC3G,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,8GAA8G;IAC9G,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,mHAAmH;AACnH,MAAM,WAAW,eAAe;IAC9B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,kFAAkF;IAClF,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,0CAA0C;IAC1C,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,sFAAsF;IACtF,YAAY,EAAE,kBAAkB,CAAC;IACjC,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;CACd;AAoBD;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAC3C,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,WAAW,EAAE,EACtB,IAAI,GAAE,eAAoB,GACzB,OAAO,CAAC,iBAAiB,CAAC,CAiG5B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,SAAiB,GAAG,WAAW,CAKpE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,GAAG,WAAW,CAK/E"}

package/dist/discovery.js

@@ -0,0 +1,199 @@
+// discovery.ts — cross-installation claim discovery (D-005).
+//
+// THE PROBLEM (DECISIONS.md D-005): a buyer's claim about a seller lives only
+// in that buyer's local ledger. A different buyer, on a separate installation,
+// cannot see it via get_delivery_history before deciding to pay the same
+// seller. get_delivery_history is, by construction, local-only.
+//
+// THE INSIGHT that makes findability solvable WITHOUT a trusted index: our
+// claims are already self-verifying (claimId is a content hash, signature
+// recovers to buyerAddress). So discovery does not need anyone to be trusted.
+// Claims can be published anywhere, and whoever discovers them re-verifies each
+// one locally. A source that injects a forged claim is caught by verifyClaim;
+// a source that omits claims is the D-006 completeness problem, unchanged and
+// carried over here (analyzeCompleteness still runs on the aggregate). So
+// findability and verification compose cleanly: gather from anywhere untrusted,
+// verify everything locally.
+//
+// WHAT THIS MODULE IS: the trustless client-side aggregation. Given several
+// independent SOURCES (the local ledger, and any host-independent substrate a
+// buyer chooses to also read), it fetches claims for a seller from each,
+// de-duplicates by claimId, RE-VERIFIES every single one regardless of which
+// source produced it, and runs the completeness analysis over the surviving
+// set. The result carries per-source accounting so the caller can see what
+// each source contributed and what was rejected.
+//
+// WHAT THIS MODULE IS NOT, stated so it is never oversold:
+//   - It does not run, host, or endorse any index. A `ClaimSource` is an
+//     UNTRUSTED input; the trust comes entirely from re-verifying each claim.
+//   - It does not solve completeness. If a source silently omits claims, this
+//     cannot invent them; analyzeCompleteness carries over the same honest
+//     detection/limits from D-006 (catches a hidden middle claim in a chain
+//     it can see, not a hidden tail or a hidden whole buyer).
+//   - The production substrate (EAS on Base, ERC-8004) is deliberately NOT
+//     wired here. That needs gas, a live chain, and a real integrator; see
+//     DECISIONS.md D-005/D-012. This module is the substrate-agnostic seam
+//     plus a reference in-memory/static source for simulation and tests.
+import { DeliveryClaimSchema } from "./schema.js";
+import { verifyClaim } from "./signing.js";
+import { claimsForSeller } from "./ledger.js";
+import { analyzeCompleteness } from "./completeness.js";
+// Bound the work a single untrusted source can force. Defense against VOLUME
+// (a source returning millions of entries, or an attacker generating millions
+// of genuinely-valid self-signed claims), not against Sybil (see the note).
+// Overridable per call via DiscoverOptions.
+const MAX_CLAIMS_PER_SOURCE = 10_000;
+const MAX_TOTAL_CLAIMS = 50_000;
+const DISCOVERY_NOTE = "Aggregated from independent, UNTRUSTED sources. Every claim shown was re-verified locally (claimId recomputed and " +
+    "signature recovered to buyerAddress), so a source cannot inject a forged claim. What verification proves is narrow: " +
+    "it proves AUTHORSHIP of the content, NOT that a real payment or delivery happened (settlementRef is not checked " +
+    "on-chain here) and NOT that buyers are distinct. So a single keypair can still flood valid positive claims to " +
+    "inflate a seller, or valid negatives to grief one; volume and Sybil are not addressed by aggregation. This solves " +
+    "findability across installations, NOT completeness: a source can still omit claims, and no aggregation can invent " +
+    "what no source reveals. The completeness field carries the same D-006 detection and limits over the aggregate. Add " +
+    "more independent sources to raise the cost of a coordinated omission; it never reaches a proof. See DECISIONS.md D-005.";
+function lower(s) {
+    return s.toLowerCase();
+}
+function timestampMs(claim) {
+    return Date.parse(claim.timestamp);
+}
+/**
+ * Trustless cross-installation aggregation. Reads a seller's claims from every
+ * source, de-duplicates by claimId, re-verifies each one (dropping anything
+ * that fails), and runs completeness over the survivors. No source is trusted;
+ * a source that throws is recorded and skipped, never fatal.
+ *
+ * Order note: sources are processed in the order given, purely so per-source
+ * `accepted`/`duplicates` accounting is deterministic (the first source to
+ * carry a given claimId gets the `accepted` credit; later ones counting it as
+ * a duplicate). The final `claims` array is sorted by timestamp regardless of
+ * source order, so the aggregate itself does not depend on which source is
+ * listed first.
+ */
+export async function discoverDeliveryHistory(sellerAddress, sources, opts = {}) {
+    const maxPerSource = opts.maxClaimsPerSource ?? MAX_CLAIMS_PER_SOURCE;
+    const maxTotal = opts.maxTotalClaims ?? MAX_TOTAL_CLAIMS;
+    const byId = new Map();
+    const sourceReports = [];
+    for (const source of sources) {
+        let fetched;
+        try {
+            fetched = await source.fetchForSeller(sellerAddress);
+        }
+        catch (e) {
+            sourceReports.push({ name: source.name, fetched: 0, accepted: 0, rejected: 0, wrongSeller: 0, duplicates: 0, error: e.message });
+            continue;
+        }
+        // An untrusted source may RESOLVE (not reject) to anything, including a
+        // non-array: malformed JSON from a real HTTP/EAS source, or a hostile one
+        // trying to abort the whole aggregation. Treat that as a per-source error
+        // and keep going. Without this guard the `for...of` below throws
+        // "not iterable", rejects discoverDeliveryHistory entirely, and censors
+        // every other source including the local ledger — defeating the very
+        // fault-isolation this function promises.
+        if (!Array.isArray(fetched)) {
+            sourceReports.push({ name: source.name, fetched: 0, accepted: 0, rejected: 0, wrongSeller: 0, duplicates: 0, error: "source did not return an array" });
+            continue;
+        }
+        let accepted = 0;
+        let rejected = 0;
+        let wrongSeller = 0;
+        let duplicates = 0;
+        // Bound the work this source can force: examine at most maxPerSource
+        // entries, and stop growing the aggregate past maxTotal. A source that
+        // returns more is marked `truncated` rather than allowed to exhaust
+        // CPU/memory on untrusted input.
+        const limit = Math.min(fetched.length, maxPerSource);
+        const truncated = fetched.length > maxPerSource;
+        for (let i = 0; i < limit; i++) {
+            if (byId.size >= maxTotal)
+                break;
+            const claim = fetched[i];
+            // Re-verify EVERY claim, from EVERY source, no exceptions: this is the
+            // entire trust model. A source is just bytes until verifyClaim passes.
+            let verdict;
+            try {
+                verdict = verifyClaim(claim);
+            }
+            catch {
+                // computeClaimId can throw on pathological content (e.g. promisedSpec
+                // past MAX_DEPTH); treat exactly like a failed verification.
+                rejected++;
+                continue;
+            }
+            if (!verdict.ok) {
+                rejected++;
+                continue;
+            }
+            // Valid, but about a DIFFERENT seller: honest-but-off-topic, tracked
+            // separately from cryptographic rejections so an honest source that
+            // simply returns other sellers' claims is not mislabeled as feeding
+            // forgeries (case-insensitive, matching ledger semantics).
+            if (lower(claim.sellerAddress) !== lower(sellerAddress)) {
+                wrongSeller++;
+                continue;
+            }
+            const key = lower(claim.claimId);
+            if (byId.has(key)) {
+                duplicates++;
+                continue;
+            }
+            // Store the schema-parsed form so no unverified, attacker-attached
+            // top-level key rides into the result. verifyClaim already proved the
+            // content hashes to claimId; parsing strips anything outside the signed
+            // shape. It cannot fail here (the claim already passed verifyClaim,
+            // whose computeClaimId parses the same content), but guard anyway since
+            // the input is untrusted.
+            let parsed;
+            try {
+                parsed = DeliveryClaimSchema.parse(claim);
+            }
+            catch {
+                rejected++;
+                continue;
+            }
+            byId.set(key, parsed);
+            accepted++;
+        }
+        const report = { name: source.name, fetched: fetched.length, accepted, rejected, wrongSeller, duplicates };
+        if (truncated)
+            report.truncated = true;
+        sourceReports.push(report);
+    }
+    const claims = [...byId.values()].sort((a, b) => timestampMs(a) - timestampMs(b));
+    return {
+        sellerAddress,
+        count: claims.length,
+        claims,
+        sources: sourceReports,
+        completeness: analyzeCompleteness(claims),
+        note: DISCOVERY_NOTE,
+    };
+}
+/**
+ * A source backed by THIS installation's local ledger. This is the one source
+ * that is already trusted in the sense that its own read path re-verifies, but
+ * discoverDeliveryHistory re-verifies it anyway (harmless, keeps the trust
+ * model uniform: no source is special).
+ */
+export function localLedgerSource(name = "local-ledger") {
+    return {
+        name,
+        fetchForSeller: (sellerAddress) => claimsForSeller(sellerAddress),
+    };
+}
+/**
+ * A source over a fixed, in-memory list of claims. Used to simulate a
+ * host-independent substrate (a shared file, an EAS query result, another
+ * installation's export) in tests and the discovery fixture, without a network
+ * or a chain. Deliberately does NO verification itself, so the aggregation's
+ * own verification is what the tests actually exercise.
+ */
+export function staticSource(name, claims) {
+    return {
+        name,
+        fetchForSeller: async (sellerAddress) => claims.filter((c) => lower(c.sellerAddress) === lower(sellerAddress)),
+    };
+}
+//# sourceMappingURL=discovery.js.map

package/dist/discovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.js","sourceRoot":"","sources":["../src/discovery.ts"],"names":[],"mappings":"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"}

package/dist/eas.d.ts

@@ -0,0 +1,77 @@
+import { ethers } from "ethers";
+import { type DeliveryClaim } from "./schema.js";
+import { verifyClaim } from "./signing.js";
+import type { ClaimSource } from "./discovery.js";
+export declare const EAS_ADDRESS = "0x4200000000000000000000000000000000000021";
+export declare const SCHEMA_REGISTRY_ADDRESS = "0x4200000000000000000000000000000000000020";
+export declare const EAS_EXPLORER: {
+    readonly 8453: "https://base.easscan.org";
+    readonly 84532: "https://base-sepolia.easscan.org";
+};
+export declare const SCHEMA_STRING = "bytes32 claimId,string claim";
+/** Deterministic schema UID: keccak256(abi.encodePacked(schema, resolver, revocable)). */
+export declare function computeSchemaUID(schema?: string, resolver?: string, revocable?: boolean): string;
+export declare const SCHEMA_UID: string;
+/** ABI-encode a claim into EAS attestation data for SCHEMA_STRING. */
+export declare function encodeClaimData(claim: DeliveryClaim): string;
+/**
+ * Decode EAS attestation data back into a claim. Returns null if the data does
+ * not decode or the JSON does not parse into our claim shape. NEVER trusts the
+ * result: the caller (easSource / discoverDeliveryHistory) re-verifies with
+ * verifyClaim. The on-chain bytes32 claimId is cross-checked against the JSON's
+ * own claimId, so a mismatch is dropped here as malformed.
+ */
+export declare function decodeClaimData(data: string): DeliveryClaim | null;
+/**
+ * Register our schema if it does not already exist on this chain. The schema
+ * UID is deterministic, so a duplicate register() reverts with AlreadyExists;
+ * we check first via getSchema and only register when absent. Requires a
+ * funded signer. Returns the schema UID.
+ */
+export declare function ensureSchema(signer: ethers.Signer): Promise<string>;
+export interface PublishResult {
+    uid: string;
+    txHash: string;
+    recipient: string;
+}
+/**
+ * Publish one claim to EAS as an attestation with recipient = sellerAddress, so
+ * it is discoverable by that seller. The attester is the signer (normally the
+ * buyer who signed the claim). Requires a funded signer. Returns the new
+ * attestation UID and tx hash.
+ */
+export declare function publishClaim(signer: ethers.Signer, claim: DeliveryClaim): Promise<PublishResult>;
+/**
+ * The minimal on-chain read surface easSource needs. Split out as an injection
+ * seam so the decode/aggregation path is unit-testable without a live chain
+ * (same pattern as erc8004.ts's ContractFactory). Real implementation reads
+ * Attested logs filtered by recipient + schema, then getAttestation per uid.
+ */
+export interface AttestationReader {
+    /** UIDs of attestations of our schema whose recipient == seller. */
+    uidsForSeller(sellerAddress: string): Promise<string[]>;
+    /** The raw ABI-encoded `data` field of one attestation. */
+    dataForUid(uid: string): Promise<string>;
+}
+/** Build a real AttestationReader over a JSON-RPC endpoint (getLogs + getAttestation). */
+export declare function rpcAttestationReader(rpcUrl: string, opts?: {
+    fromBlock?: number;
+    schemaUID?: string;
+}): AttestationReader;
+/**
+ * An untrusted ClaimSource backed by EAS. fetchForSeller reads the seller's
+ * attestation UIDs, decodes each back into a claim, and returns them. It does
+ * NOT verify (discoverDeliveryHistory does that for every source uniformly); it
+ * only drops entries that fail to decode into our claim shape. A malformed or
+ * hostile attestation therefore either fails to decode here or fails
+ * verifyClaim in discovery, never reaching the result as genuine.
+ */
+export declare function easSource(reader: AttestationReader, name?: string): ClaimSource;
+/** Convenience: an EAS-backed source directly from an RPC URL. */
+export declare function easSourceFromRpc(rpcUrl: string, opts?: {
+    fromBlock?: number;
+    schemaUID?: string;
+    name?: string;
+}): ClaimSource;
+export { verifyClaim };
+//# sourceMappingURL=eas.d.ts.map

package/dist/eas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eas.d.ts","sourceRoot":"","sources":["../src/eas.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGlD,eAAO,MAAM,WAAW,+CAA+C,CAAC;AACxE,eAAO,MAAM,uBAAuB,+CAA+C,CAAC;AAEpF,eAAO,MAAM,YAAY;;;CAGf,CAAC;AAqCX,eAAO,MAAM,aAAa,iCAAiC,CAAC;AAG5D,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAAC,MAAM,SAAgB,EAAE,QAAQ,SAAqB,EAAE,SAAS,UAAmB,GAAG,MAAM,CAE5H;AAED,eAAO,MAAM,UAAU,QAAqB,CAAC;AAI7C,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAE5D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAgBlE;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAUzE;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CA6BtG;AAMD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,oEAAoE;IACpE,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACxD,2DAA2D;IAC3D,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC1C;AAED,0FAA0F;AAC1F,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,iBAAiB,CAqB7H;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,iBAAiB,EAAE,IAAI,SAAQ,GAAG,WAAW,CAmB9E;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,WAAW,CAElI;AAID,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/eas.js

@@ -0,0 +1,193 @@
+// eas.ts — publish a delivery claim to, and discover it from, the Ethereum
+// Attestation Service (EAS) on Base. This is the concrete, host-independent
+// substrate D-005/D-012 pointed at: a public chain anyone can read, so a buyer
+// on one installation can find a claim another buyer published, and verify it
+// locally (discovery.ts re-verifies every claim, so EAS is just an untrusted
+// ClaimSource like any other).
+//
+// Plain ethers only, no eas-sdk dependency. EAS is an OP-Stack predeploy, so
+// the contract addresses are identical on Base mainnet (8453) and Base Sepolia
+// (84532). Everything here is caller-parameterised (rpcUrl, signer): this
+// package never bundles an RPC, a key, or gas, and never becomes the index.
+//
+// Verified against the EAS contract sources (IEAS.sol, Common.sol,
+// SchemaRegistry.sol) and the base / base-sepolia deployment artifacts, 2026-09-06.
+import { ethers } from "ethers";
+import { DeliveryClaimSchema } from "./schema.js";
+import { verifyClaim } from "./signing.js";
+// OP-Stack predeploys: same on every Base network.
+export const EAS_ADDRESS = "0x4200000000000000000000000000000000000021";
+export const SCHEMA_REGISTRY_ADDRESS = "0x4200000000000000000000000000000000000020";
+export const EAS_EXPLORER = {
+    8453: "https://base.easscan.org",
+    84532: "https://base-sepolia.easscan.org",
+};
+const EAS_ABI = [
+    "function attest((bytes32 schema,(address recipient,uint64 expirationTime,bool revocable,bytes32 refUID,bytes data,uint256 value) data) request) payable returns (bytes32)",
+    "function getAttestation(bytes32 uid) view returns ((bytes32 uid,bytes32 schema,uint64 time,uint64 expirationTime,uint64 revocationTime,bytes32 refUID,address recipient,address attester,bool revocable,bytes data))",
+    "event Attested(address indexed recipient, address indexed attester, bytes32 uid, bytes32 indexed schemaUID)",
+];
+const SCHEMA_REGISTRY_ABI = [
+    "function register(string schema, address resolver, bool revocable) returns (bytes32)",
+    "function getSchema(bytes32 uid) view returns ((bytes32 uid,address resolver,bool revocable,string schema))",
+];
+// Our schema. We carry the WHOLE signed claim as JSON in one field, so a
+// discovered attestation is fully self-verifying offline (decode -> parse ->
+// verifyClaim), with no second lookup anywhere. claimId is also stored as a
+// bytes32 for a cheap on-chain cross-reference. Types + order are what matter
+// for ABI-encoding; the names are metadata.
+export const SCHEMA_STRING = "bytes32 claimId,string claim";
+const SCHEMA_REVOCABLE = true;
+/** Deterministic schema UID: keccak256(abi.encodePacked(schema, resolver, revocable)). */
+export function computeSchemaUID(schema = SCHEMA_STRING, resolver = ethers.ZeroAddress, revocable = SCHEMA_REVOCABLE) {
+    return ethers.keccak256(ethers.solidityPacked(["string", "address", "bool"], [schema, resolver, revocable]));
+}
+export const SCHEMA_UID = computeSchemaUID();
+const coder = ethers.AbiCoder.defaultAbiCoder();
+/** ABI-encode a claim into EAS attestation data for SCHEMA_STRING. */
+export function encodeClaimData(claim) {
+    return coder.encode(["bytes32", "string"], [claim.claimId, JSON.stringify(claim)]);
+}
+/**
+ * Decode EAS attestation data back into a claim. Returns null if the data does
+ * not decode or the JSON does not parse into our claim shape. NEVER trusts the
+ * result: the caller (easSource / discoverDeliveryHistory) re-verifies with
+ * verifyClaim. The on-chain bytes32 claimId is cross-checked against the JSON's
+ * own claimId, so a mismatch is dropped here as malformed.
+ */
+export function decodeClaimData(data) {
+    let claimId;
+    let json;
+    try {
+        [claimId, json] = coder.decode(["bytes32", "string"], data);
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = DeliveryClaimSchema.parse(JSON.parse(json));
+    }
+    catch {
+        return null;
+    }
+    if (parsed.claimId.toLowerCase() !== claimId.toLowerCase())
+        return null;
+    return parsed;
+}
+/**
+ * Register our schema if it does not already exist on this chain. The schema
+ * UID is deterministic, so a duplicate register() reverts with AlreadyExists;
+ * we check first via getSchema and only register when absent. Requires a
+ * funded signer. Returns the schema UID.
+ */
+export async function ensureSchema(signer) {
+    const registry = new ethers.Contract(SCHEMA_REGISTRY_ADDRESS, SCHEMA_REGISTRY_ABI, signer);
+    const existing = await registry.getSchema(SCHEMA_UID);
+    // getSchema returns a zero-uid struct when the schema is not registered.
+    if (existing && existing.uid && existing.uid.toLowerCase() === SCHEMA_UID.toLowerCase()) {
+        return SCHEMA_UID;
+    }
+    const tx = await registry.register(SCHEMA_STRING, ethers.ZeroAddress, SCHEMA_REVOCABLE);
+    await tx.wait();
+    return SCHEMA_UID;
+}
+/**
+ * Publish one claim to EAS as an attestation with recipient = sellerAddress, so
+ * it is discoverable by that seller. The attester is the signer (normally the
+ * buyer who signed the claim). Requires a funded signer. Returns the new
+ * attestation UID and tx hash.
+ */
+export async function publishClaim(signer, claim) {
+    const eas = new ethers.Contract(EAS_ADDRESS, EAS_ABI, signer);
+    const tx = await eas.attest({
+        schema: SCHEMA_UID,
+        data: {
+            recipient: claim.sellerAddress,
+            expirationTime: 0n,
+            revocable: SCHEMA_REVOCABLE,
+            refUID: ethers.ZeroHash,
+            data: encodeClaimData(claim),
+            value: 0n,
+        },
+    });
+    const receipt = await tx.wait();
+    if (!receipt)
+        throw new Error("attest transaction had no receipt (dropped or replaced)");
+    const iface = new ethers.Interface(EAS_ABI);
+    let uid = "";
+    for (const log of receipt.logs) {
+        try {
+            const parsed = iface.parseLog(log);
+            if (parsed && parsed.name === "Attested") {
+                uid = parsed.args.uid;
+                break;
+            }
+        }
+        catch {
+            // not an EAS log, skip
+        }
+    }
+    return { uid, txHash: receipt.hash, recipient: claim.sellerAddress };
+}
+/** Build a real AttestationReader over a JSON-RPC endpoint (getLogs + getAttestation). */
+export function rpcAttestationReader(rpcUrl, opts = {}) {
+    const provider = new ethers.JsonRpcProvider(rpcUrl);
+    const eas = new ethers.Contract(EAS_ADDRESS, EAS_ABI, provider);
+    const schemaUID = opts.schemaUID ?? SCHEMA_UID;
+    const attestedTopic0 = ethers.id("Attested(address,address,bytes32,bytes32)");
+    return {
+        uidsForSeller: async (sellerAddress) => {
+            const logs = await provider.getLogs({
+                address: EAS_ADDRESS,
+                topics: [attestedTopic0, ethers.zeroPadValue(sellerAddress, 32), null, schemaUID],
+                fromBlock: opts.fromBlock ?? 0,
+                toBlock: "latest",
+            });
+            // uid is the only non-indexed value: it sits in log.data.
+            return logs.map((l) => l.data);
+        },
+        dataForUid: async (uid) => {
+            const att = await eas.getAttestation(uid);
+            return att.data;
+        },
+    };
+}
+/**
+ * An untrusted ClaimSource backed by EAS. fetchForSeller reads the seller's
+ * attestation UIDs, decodes each back into a claim, and returns them. It does
+ * NOT verify (discoverDeliveryHistory does that for every source uniformly); it
+ * only drops entries that fail to decode into our claim shape. A malformed or
+ * hostile attestation therefore either fails to decode here or fails
+ * verifyClaim in discovery, never reaching the result as genuine.
+ */
+export function easSource(reader, name = "eas") {
+    return {
+        name,
+        fetchForSeller: async (sellerAddress) => {
+            const uids = await reader.uidsForSeller(sellerAddress);
+            const claims = [];
+            for (const uid of uids) {
+                let data;
+                try {
+                    data = await reader.dataForUid(uid);
+                }
+                catch {
+                    continue; // unreadable attestation, skip
+                }
+                const claim = decodeClaimData(data);
+                if (claim)
+                    claims.push(claim);
+            }
+            return claims;
+        },
+    };
+}
+/** Convenience: an EAS-backed source directly from an RPC URL. */
+export function easSourceFromRpc(rpcUrl, opts = {}) {
+    return easSource(rpcAttestationReader(rpcUrl, opts), opts.name ?? "eas");
+}
+// Re-export so callers see verifyClaim is what makes an EAS-sourced claim
+// trustworthy, not EAS itself.
+export { verifyClaim };
+//# sourceMappingURL=eas.js.map

package/dist/eas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eas.js","sourceRoot":"","sources":["../src/eas.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacity-attest",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "MCP server for capacity-delivery attestations: after an x402 payment for compute capacity (GPU-hours, storage, API credits, bandwidth), the paying agent leaves a signed, factual claim of what was actually delivered, so other agents can check a seller's delivery history before paying. No reputation score, no judgment, no financial instrument.",
   "keywords": [
     "mcp",
@@ -40,7 +40,9 @@
     "test": "vitest run",
     "start": "node dist/index.js",
     "demo": "tsx examples/demo.ts",
-    "fixture": "tsx examples/completeness-fixture.ts"
+    "fixture": "tsx examples/completeness-fixture.ts",
+    "discovery-fixture": "tsx examples/discovery-fixture.ts",
+    "eas-demo": "tsx examples/eas-live-demo.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",