capacity-attest 0.4.0 → 0.6.0

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,81 @@
+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. `signer` only pays gas and writes the
+ * transaction; it does not need to be, and normally is not, the buyer. The
+ * buyer identity lives entirely inside `claim` (buyerAddress, checked by
+ * verifyClaim against the signature over claimId): nothing on the read path
+ * (easSource, discoverDeliveryHistory) ever looks at who published the
+ * attestation, only at what the claim itself proves. 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;;;;;;;;;GASG;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,197 @@
+// 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. `signer` only pays gas and writes the
+ * transaction; it does not need to be, and normally is not, the buyer. The
+ * buyer identity lives entirely inside `claim` (buyerAddress, checked by
+ * verifyClaim against the signature over claimId): nothing on the read path
+ * (easSource, discoverDeliveryHistory) ever looks at who published the
+ * attestation, only at what the claim itself proves. 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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"}