@goodmeta/agent-verifier 0.2.0 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # @goodmeta/agent-verifier
 
-Can this agent spend $X on Y right now? One function call.
+Implements the [Budget Authority Protocol](https://github.com/goodmeta/agent-payments-landscape/blob/main/specs/budget-authority-protocol.md). Can this agent spend $X on Y right now? One function call.
 
 ```ts
 import { checkPolicy } from "@goodmeta/agent-verifier"
@@ -19,7 +19,7 @@ Or with the hosted verifier (cross-agent budget tracking):
 ```ts
 import { VerifierClient } from "@goodmeta/agent-verifier"
 
-const verifier = new VerifierClient({ apiKey: "gm_live_..." })
+const verifier = new VerifierClient({ apiKey: "gm_test_..." })
 const { approved, verificationId } = await verifier.verify(mandate, {
   amount: "3000",
   idempotencyKey: "tx-1",
@@ -88,26 +88,52 @@ checkPolicy(policy, {
 // → { approved: false, reason: "CODE_NOT_ALLOWED", detail: 'Code "storage" not in allowed list' }
 ```
 
-### AP2 mandate verification
+### Real AP2 mandate verification (dSD-JWT)
 
-For agents carrying [AP2](https://ap2-protocol.org/) cryptographic mandates (Google, 60+ partners). Verifies EIP-712 signatures and checks constraints.
+[AP2](https://ap2-protocol.org/) mandates (Google, 60+ partners) are **not** plain signed JSON — they are **dSD-JWT delegation chains**: an issuer-signed SD-JWT root plus N KB-SD-JWT hops, each hop signed by the previous hop's `cnf.jwk`, hash-chained via `sd_hash`/`issuer_jwt_hash`, ES256/P-256. The `ap2` namespace verifies the whole chain and evaluates the mandate's constraints. It is **ported byte-exact from AP2's reference SDK** (pinned commit, 65 golden vectors) and is **stricter than AP2 on every trust decision** — see [`AP2-AUDIT.md`](./AP2-AUDIT.md).
 
 ```ts
-import {
-  verifyIntentSignature,
-  checkConstraints,
-} from "@goodmeta/agent-verifier"
+import { ap2 } from "@goodmeta/agent-verifier"
+
+// 1. Verify the delegation chain. Pass the root issuer key (or an x5c/kid
+//    provider) and the expected audience + nonce — both REQUIRED (fail-closed).
+const tokens = ap2.splitChain(compactChain)
+const payloads = await ap2.verifyChain(tokens, rootIssuerJwk, {
+  expectedAud: "merchant",
+  expectedNonce: "nonce-1",
+})
+// signatures, cnf hop-chaining, sd_hash binding, typ rules, aud/nonce all
+// verified — throws on any failure. payloads = [open, ...intermediate, closed]
+
+// 2. Type the [open, closed] pair and evaluate constraints (budget, amount
+//    range, allowed payees/instruments, line-items max-flow, …).
+const chain = ap2.parsePaymentChain(payloads)
+const violations = ap2.verifyPaymentChain(chain, {
+  mandateContext: { total_amount: 0, total_uses: 0 },
+})
+if (violations.length) throw new Error(violations.join("; ")) // [] = authorized
 
-// verify the mandate signature is real
-const sig = await verifyIntentSignature(mandate)
-if (!sig.valid) throw new Error(sig.error)
+// 3. Stable receipt reference (hash of the final SD-JWT in the chain).
+const reference = ap2.receiptReference(compactChain)
+```
 
-// check spending constraints
-const check = checkConstraints(mandate, {
-  amount: "3000",
-  merchantId: "merchant-1",
-})
-if (!check.valid) throw new Error(check.error)
+For certificate-anchored roots, build a fail-closed `x5c`/`kid` provider (mandatory trusted roots, validity window, `CA:TRUE`, leaf P-256, anchor-to-root):
+
+```ts
+const provider = ap2.x5cOrKidProvider({ trustedRoots /* X509Certificate[] */ })
+const payloads = await ap2.verifyChain(tokens, provider, { expectedAud, expectedNonce })
+```
+
+### Receipts (ES256 JWS)
+
+A *Mandate Receipt* in AP2 is a Verifier-signed JWT (`iss`/`result`/`reference`). `signReceipt`/`verifyReceipt` are a plain compact ES256 JWS over the whole payload — the receipt mechanism. (They also back the simpler legacy `IntentMandate` self-hosted flow; see `examples/single-merchant.ts`.)
+
+```ts
+import { signReceipt, verifyReceipt } from "@goodmeta/agent-verifier"
+
+const token = await signReceipt(receipt, verifierPrivateJwk)
+const { valid, payload, error } = await verifyReceipt(token, verifierPublicJwk)
+if (!valid) throw new Error(error)
 ```
 
 ### Hosted verifier
@@ -118,7 +144,7 @@ When one agent's budget spans multiple services — Mistral AND Groq AND CoreWea
 import { VerifierClient } from "@goodmeta/agent-verifier"
 
 const verifier = new VerifierClient({
-  apiKey: "gm_live_...",
+  apiKey: "gm_test_...",
   baseUrl: "https://verifier.goodmeta.co",
 })
 
@@ -149,16 +175,26 @@ if (approved) {
 | --- | --- |
 | `checkPolicy(policy, request, currentSpend?)` | Check a spending request against policy constraints |
 
-### AP2 mandates
+### AP2 dSD-JWT verifier (`ap2.*`)
 
 | Function | Description |
 | --- | --- |
-| `verifyIntentSignature(mandate)` | Verify EIP-712 signature on an Intent Mandate |
-| `verifyCartSignature(mandate)` | Verify EIP-712 signature on a Cart Mandate |
-| `checkConstraints(mandate, tx)` | Check budget, merchant, category, and temporal constraints |
-| `signIntentMandate(mandate, account)` | User signs autonomous spending authority |
-| `signCartMandate(mandate, account)` | Merchant signs price commitment |
-| `approveCartMandate(mandate, account)` | User approves a specific purchase |
+| `ap2.splitChain(compact)` | Split a `~~`-joined dSD-JWT chain into parsed tokens |
+| `ap2.verifyChain(tokens, keyOrProvider, opts)` | Verify the full delegation chain (signatures, cnf hop-chaining, binding, typ, terminal aud/nonce); returns per-hop payloads, throws on failure |
+| `ap2.x5cOrKidProvider(opts)` | Build a fail-closed root-key provider from `x5c` certs or a `kid` lookup |
+| `ap2.parsePaymentChain` / `ap2.verifyPaymentChain` | Type the `[open, closed]` payment pair; evaluate constraints + linkage (`[]` = ok) |
+| `ap2.parseCheckoutChain` / `ap2.verifyCheckoutChain` | Same for checkout; self-computes `checkout_hash` from the embedded `checkout_jwt` |
+| `ap2.checkPaymentConstraints` / `ap2.checkCheckoutConstraints` | Evaluate the 8 payment / 2 checkout constraints directly |
+| `ap2.receiptReference(compact)` | Stable receipt reference (`sd_hash` of the final SD-JWT) |
+| `ap2.*Schema` / types | zod schemas + types for the snake_case AP2 mandates |
+
+### Receipts (ES256 JWS)
+
+| Function | Description |
+| --- | --- |
+| `signReceipt(payload, privateJwk)` | Sign a payload as a compact ES256 JWS (AP2 receipt format) |
+| `verifyReceipt(token, publicJwk)` | Verify the JWS signature; returns the trusted payload |
+| `checkConstraints(mandate, tx)` | (Legacy) check budget/merchant/category/temporal constraints on an `IntentMandate` |
 
 ### Hosted verifier client
 
@@ -166,9 +202,14 @@ if (approved) {
 | --- | --- |
 | `verifier.verify(mandate, tx)` | Verify with full mandate object + place budget hold |
 | `verifier.verifyById(mandateId, tx)` | Verify by ID (agent passes ID, verifier has mandate on file) |
-| `verifier.settle(id, result)` | Confirm payment or release hold |
+| `verifier.createBudget(opts)` | Create a budget envelope — no signature; the API key is the trust anchor |
+| `verifier.settle(id, result)` | Confirm payment (debit budget) or release the hold |
+| `verifier.release(id)` | Return a pre-commit hold to the budget (before settlement) |
+| `verifier.refund(id, cents, key)` | Reverse a settled payment, full or partial (idempotent) |
 | `verifier.getMandateState(id)` | Query budget, tx count, and history |
 
+Calls apply a timeout and throw a typed `VerifierError` (with HTTP `status` + `body`) on transport, auth, or server failures; a denied verification is returned with `approved: false`, not thrown.
+
 ## Related
 
 - [AP2](https://ap2-protocol.org/) — Agent payment authorization by Google (60+ partners)

package/dist/ap2/chain.d.ts

@@ -0,0 +1,43 @@
+/**
+ * dSD-JWT delegation-chain walk.
+ *
+ * Port of AP2's `sdjwt/chain.py::verify_chain` (+ `_check_time_claims`):
+ * verify the root SD-JWT, then each KB-SD-JWT hop under the previous hop's
+ * `cnf.jwk`, returning one effective payload per hop (`[open, …, closed]`).
+ *
+ * Hardenings over AP2's reference (PLAN §5):
+ *   H4 — `expectedAud`+`expectedNonce` are REQUIRED for any chain that has KB
+ *        hops (AP2 leaves them optional); fail closed if absent.
+ *   H5 — DoS caps enforced BEFORE any crypto (chain depth, per-token bytes,
+ *        disclosures per token).
+ * The signature/binding/typ/cnf checks live in the per-primitive modules
+ * (`sd-jwt.ts`, `kb-sd-jwt.ts`), as in AP2.
+ */
+import type { ParsedToken } from "./parse.js";
+import { type VerificationKey } from "./sd-jwt.js";
+type Json = Record<string, unknown>;
+/** DoS caps (H5) — frozen so a consumer of the public barrel can't weaken them
+ * process-wide (`as const` is compile-time only). */
+export declare const CHAIN_CAPS: Readonly<{
+    maxDepth: 8;
+    maxTokenBytes: number;
+    maxDisclosuresPerToken: 64;
+}>;
+/** Resolves the root token's verification key (x5c/kid trust → P4). */
+export type RootKeyProvider = (root: ParsedToken) => VerificationKey;
+export interface VerifyChainOptions {
+    expectedAud?: string;
+    expectedNonce?: string;
+    clockSkewSeconds?: number;
+    /** Unix seconds; defaults to the current time. Override for reproducible tests. */
+    currentTime?: number;
+}
+/**
+ * Verify a dSD-JWT delegation chain and return per-hop effective payloads.
+ *
+ * @param tokens    parsed chain segments (root first), e.g. from `splitChain`.
+ * @param rootKey   the root issuer key, or a provider `(root) => key` (P4 x5c/kid).
+ */
+export declare function verifyChain(tokens: ParsedToken[], rootKey: VerificationKey | RootKeyProvider, opts?: VerifyChainOptions): Promise<Json[]>;
+export {};
+//# sourceMappingURL=chain.d.ts.map

package/dist/ap2/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../src/ap2/chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAA6D,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAG9G,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpC;qDACqD;AACrD,eAAO,MAAM,UAAU;;;;EAIrB,CAAC;AAIH,uEAAuE;AACvE,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,WAAW,KAAK,eAAe,CAAC;AAErE,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mFAAmF;IACnF,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAgCD;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,WAAW,EAAE,EACrB,OAAO,EAAE,eAAe,GAAG,eAAe,EAC1C,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,IAAI,EAAE,CAAC,CAuCjB"}

package/dist/ap2/chain.js

@@ -0,0 +1,100 @@
+/**
+ * dSD-JWT delegation-chain walk.
+ *
+ * Port of AP2's `sdjwt/chain.py::verify_chain` (+ `_check_time_claims`):
+ * verify the root SD-JWT, then each KB-SD-JWT hop under the previous hop's
+ * `cnf.jwk`, returning one effective payload per hop (`[open, …, closed]`).
+ *
+ * Hardenings over AP2's reference (PLAN §5):
+ *   H4 — `expectedAud`+`expectedNonce` are REQUIRED for any chain that has KB
+ *        hops (AP2 leaves them optional); fail closed if absent.
+ *   H5 — DoS caps enforced BEFORE any crypto (chain depth, per-token bytes,
+ *        disclosures per token).
+ * The signature/binding/typ/cnf checks live in the per-primitive modules
+ * (`sd-jwt.ts`, `kb-sd-jwt.ts`), as in AP2.
+ */
+import { verifyRootSdJwt, resolveDelegateItems } from "./sd-jwt.js";
+import { verifyKbHop } from "./kb-sd-jwt.js";
+/** DoS caps (H5) — frozen so a consumer of the public barrel can't weaken them
+ * process-wide (`as const` is compile-time only). */
+export const CHAIN_CAPS = Object.freeze({
+    maxDepth: 8,
+    maxTokenBytes: 64 * 1024,
+    maxDisclosuresPerToken: 64,
+});
+const DEFAULT_CLOCK_SKEW_SECONDS = 300;
+function enforceCaps(tokens) {
+    if (tokens.length > CHAIN_CAPS.maxDepth) {
+        throw new Error(`Chain too deep: ${tokens.length} tokens > cap ${CHAIN_CAPS.maxDepth}`);
+    }
+    tokens.forEach((t, i) => {
+        if (t.canonical.length > CHAIN_CAPS.maxTokenBytes) {
+            throw new Error(`Token ${i} exceeds ${CHAIN_CAPS.maxTokenBytes} bytes`);
+        }
+        if (t.disclosures.length > CHAIN_CAPS.maxDisclosuresPerToken) {
+            throw new Error(`Token ${i} has ${t.disclosures.length} disclosures > cap ${CHAIN_CAPS.maxDisclosuresPerToken}`);
+        }
+    });
+}
+/** Port of `_check_time_claims`: reject expired tokens and future-dated `iat`. */
+function checkTimeClaims(payloads, tokenIndex, now, skew) {
+    for (const p of payloads) {
+        const exp = p["exp"];
+        if (exp !== undefined && exp !== null) {
+            if (typeof exp !== "number")
+                throw new Error(`Token ${tokenIndex} has invalid 'exp' claim type`);
+            if (now > exp + skew)
+                throw new Error(`Token ${tokenIndex} expired at ${exp}`);
+        }
+        const iat = p["iat"];
+        if (iat !== undefined && iat !== null) {
+            if (typeof iat !== "number")
+                throw new Error(`Token ${tokenIndex} has invalid 'iat' claim type`);
+            if (iat > now + skew)
+                throw new Error(`Token ${tokenIndex} iat is in the future: ${iat}`);
+        }
+    }
+}
+/**
+ * Verify a dSD-JWT delegation chain and return per-hop effective payloads.
+ *
+ * @param tokens    parsed chain segments (root first), e.g. from `splitChain`.
+ * @param rootKey   the root issuer key, or a provider `(root) => key` (P4 x5c/kid).
+ */
+export async function verifyChain(tokens, rootKey, opts = {}) {
+    if (tokens.length === 0)
+        throw new Error("Tokens list cannot be empty");
+    enforceCaps(tokens); // H5 — before any crypto
+    // H4 — aud+nonce mandatory for any KB-bearing chain (fail closed).
+    if (tokens.length > 1 && (!opts.expectedAud || !opts.expectedNonce)) {
+        throw new Error("expectedAud and expectedNonce are required to verify a chain with KB-SD-JWT hops");
+    }
+    const skew = opts.clockSkewSeconds ?? DEFAULT_CLOCK_SKEW_SECONDS;
+    const now = opts.currentTime ?? Math.floor(Date.now() / 1000);
+    const payloads = [];
+    // Root (index 0).
+    const rootKeyResolved = typeof rootKey === "function" ? rootKey(tokens[0]) : rootKey;
+    let prev = await verifyRootSdJwt(tokens[0], rootKeyResolved);
+    checkTimeClaims([prev.verifiedPayload], 0, now, skew);
+    checkTimeClaims(prev.delegateItems, 0, now, skew);
+    payloads.push(...(prev.delegateItems.length ? prev.delegateItems : [prev.verifiedPayload]));
+    // KB-SD-JWT hops (index 1..n-1) verify under the previous hop's cnf.jwk.
+    for (let i = 1; i < tokens.length; i++) {
+        const isLast = i === tokens.length - 1;
+        const payload = await verifyKbHop(tokens[i], prev, {
+            expectedAud: isLast ? opts.expectedAud : undefined,
+            expectedNonce: isLast ? opts.expectedNonce : undefined,
+            requireTerminal: isLast, // H4 anti-truncation: last hop must be terminal-typ
+        });
+        const delegateItems = resolveDelegateItems(payload["delegate_payload"], tokens[i]);
+        if (!isLast && delegateItems.length > 1) {
+            throw new Error(`Token ${i}: delegate_payload has ${delegateItems.length} disclosed items, expected exactly 1`);
+        }
+        checkTimeClaims([payload], i, now, skew);
+        checkTimeClaims(delegateItems, i, now, skew);
+        payloads.push(...(delegateItems.length ? delegateItems : [payload]));
+        prev = { token: tokens[i], verifiedPayload: payload, delegateItems };
+    }
+    return payloads;
+}
+//# sourceMappingURL=chain.js.map

package/dist/ap2/chain.js.map

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

package/dist/ap2/chains.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Typed mandate-chain wrappers + linkage + receipt reference.
+ *
+ * Ports AP2's `payment_mandate_chain.py` / `checkout_mandate_chain.py`: the
+ * per-hop effective payloads from `verifyChain` are parsed into a typed
+ * `[open, closed]` pair, then constraints are evaluated.
+ *
+ * Hardening H6 (stricter than AP2): AP2 takes the `transaction_id` /
+ * `checkout_hash` linkage as caller-supplied. We SELF-COMPUTE the
+ * `checkout_hash` from the embedded `checkout_jwt` and require it to match the
+ * mandate's own `checkout_hash` (mandatory) before evaluating constraints — a
+ * caller can't assert a linkage the bytes don't support.
+ */
+import { type OpenPaymentMandate, type PaymentMandate, type OpenCheckoutMandate, type CheckoutMandate, type Checkout, type MandateContext } from "./types.js";
+export interface PaymentChain {
+    open: OpenPaymentMandate;
+    closed: PaymentMandate;
+}
+/** Parse exactly two verified payloads into a typed payment chain. */
+export declare function parsePaymentChain(payloads: unknown[]): PaymentChain;
+export interface VerifyPaymentChainOptions {
+    /** The verified open-checkout-mandate hash to bind to (H6: pass the value
+     * self-computed by `verifyCheckoutChain`, not a caller assertion). */
+    expectedTransactionId?: string;
+    openCheckoutHash?: string;
+    mandateContext?: MandateContext;
+}
+/** Verify a payment chain's constraints + linkage. Returns [] when satisfied. */
+export declare function verifyPaymentChain(chain: PaymentChain, opts?: VerifyPaymentChainOptions): string[];
+export interface CheckoutChain {
+    open: OpenCheckoutMandate;
+    closed: CheckoutMandate;
+}
+export declare function parseCheckoutChain(payloads: unknown[]): CheckoutChain;
+/** Decode the `Checkout` object from a `checkout_jwt` payload (port of
+ * `extract_parsed_checkout_object`). The merchant signature is out of AP2's
+ * scope (CHK-07); only the payload is decoded + schema-validated. */
+export declare function extractCheckout(checkoutJwt: string): Checkout;
+export interface VerifyCheckoutChainOptions {
+    /** `_sd_alg` of the closed mandate's SD-JWT (defaults to sha-256). */
+    sdAlg?: string;
+    expectedCheckoutHash?: string;
+}
+/**
+ * Verify a checkout chain: self-compute `checkout_hash` from the embedded
+ * `checkout_jwt` and require it to match the mandate (H6), then evaluate the
+ * open mandate's constraints against the decoded checkout. Returns [].
+ */
+export declare function verifyCheckoutChain(chain: CheckoutChain, opts?: VerifyCheckoutChainOptions): string[];
+/** The closed-mandate leaf JWT of a chain (port of `get_closed_mandate_jwt`):
+ * the bare issuer JWT (no disclosures) of the final `~~`-separated segment.
+ *
+ * NOTE: this is for embedding/identifying the closed mandate. It is NOT the
+ * receipt-reference input — use `receiptReference()` for that. (AP2's SDK
+ * `get_closed_mandate_jwt` docstring suggests `sha256` of this string as the
+ * reference, but the AP2 spec (AUTH-17) defines the reference as `sd_hash` over
+ * the final SD-JWT *including disclosures*; we follow the spec. The two differ.)
+ */
+export declare function getClosedMandateJwt(presentationToken: string): string;
+/**
+ * Stable receipt `reference` for a chain (AUTH-17 / SPEC-6): the base64url hash
+ * of the FINAL SD-JWT in the chain, computed "in the same manner as `sd_hash`"
+ * — i.e. `sd_hash` over the last segment's canonical SD-JWT form (issuer JWT +
+ * disclosures). This is the spec-authoritative reference; it is deliberately
+ * NOT `sha256(getClosedMandateJwt(chain))` (see that function's note).
+ */
+export declare function receiptReference(presentationToken: string): string;
+//# sourceMappingURL=chains.d.ts.map

package/dist/ap2/chains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../../src/ap2/chains.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,EAML,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,QAAQ,EACb,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAOpB,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,kBAAkB,CAAC;IACzB,MAAM,EAAE,cAAc,CAAC;CACxB;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,YAAY,CAQnE;AAED,MAAM,WAAW,yBAAyB;IACxC;0EACsE;IACtE,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,GAAE,yBAA8B,GAAG,MAAM,EAAE,CAWtG;AAID,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,MAAM,EAAE,eAAe,CAAC;CACzB;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,aAAa,CAQrE;AAED;;qEAEqE;AACrE,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAY7D;AAED,MAAM,WAAW,0BAA0B;IACzC,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,GAAE,0BAA+B,GAAG,MAAM,EAAE,CA0BzG;AAID;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAIlE"}

package/dist/ap2/chains.js

@@ -0,0 +1,119 @@
+/**
+ * Typed mandate-chain wrappers + linkage + receipt reference.
+ *
+ * Ports AP2's `payment_mandate_chain.py` / `checkout_mandate_chain.py`: the
+ * per-hop effective payloads from `verifyChain` are parsed into a typed
+ * `[open, closed]` pair, then constraints are evaluated.
+ *
+ * Hardening H6 (stricter than AP2): AP2 takes the `transaction_id` /
+ * `checkout_hash` linkage as caller-supplied. We SELF-COMPUTE the
+ * `checkout_hash` from the embedded `checkout_jwt` and require it to match the
+ * mandate's own `checkout_hash` (mandatory) before evaluating constraints — a
+ * caller can't assert a linkage the bytes don't support.
+ */
+import { Buffer } from "node:buffer";
+import { computeValueHash, computeSdHash } from "./hash.js";
+import { canonicalChainSegment, parseToken } from "./parse.js";
+import { OpenPaymentMandateSchema, PaymentMandateSchema, OpenCheckoutMandateSchema, CheckoutMandateSchema, CheckoutSchema, } from "./types.js";
+import { checkPaymentConstraints, checkCheckoutConstraints } from "./constraints.js";
+const JWT_COMPACT_PARTS = 3;
+/** Parse exactly two verified payloads into a typed payment chain. */
+export function parsePaymentChain(payloads) {
+    if (payloads.length !== 2) {
+        throw new Error(`Payment mandate chain requires exactly 2 payloads, got ${payloads.length}`);
+    }
+    return {
+        open: OpenPaymentMandateSchema.parse(payloads[0]),
+        closed: PaymentMandateSchema.parse(payloads[1]),
+    };
+}
+/** Verify a payment chain's constraints + linkage. Returns [] when satisfied. */
+export function verifyPaymentChain(chain, opts = {}) {
+    const violations = checkPaymentConstraints(chain.open, chain.closed, {
+        openCheckoutHash: opts.openCheckoutHash,
+        mandateContext: opts.mandateContext,
+    });
+    if (opts.expectedTransactionId !== undefined && opts.expectedTransactionId !== chain.closed.transaction_id) {
+        violations.push(`Payment transaction_id mismatch: expected ${opts.expectedTransactionId}, got ${chain.closed.transaction_id}`);
+    }
+    return violations;
+}
+export function parseCheckoutChain(payloads) {
+    if (payloads.length !== 2) {
+        throw new Error(`Checkout mandate chain requires exactly 2 payloads, got ${payloads.length}`);
+    }
+    return {
+        open: OpenCheckoutMandateSchema.parse(payloads[0]),
+        closed: CheckoutMandateSchema.parse(payloads[1]),
+    };
+}
+/** Decode the `Checkout` object from a `checkout_jwt` payload (port of
+ * `extract_parsed_checkout_object`). The merchant signature is out of AP2's
+ * scope (CHK-07); only the payload is decoded + schema-validated. */
+export function extractCheckout(checkoutJwt) {
+    const parts = checkoutJwt.split(".");
+    if (parts.length !== JWT_COMPACT_PARTS) {
+        throw new Error("Malformed checkout_jwt: expected header.payload.signature");
+    }
+    let json;
+    try {
+        json = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    }
+    catch (e) {
+        throw new Error(`Invalid checkout_jwt payload: ${e.message}`);
+    }
+    return CheckoutSchema.parse(json);
+}
+/**
+ * Verify a checkout chain: self-compute `checkout_hash` from the embedded
+ * `checkout_jwt` and require it to match the mandate (H6), then evaluate the
+ * open mandate's constraints against the decoded checkout. Returns [].
+ */
+export function verifyCheckoutChain(chain, opts = {}) {
+    const violations = [];
+    // H6 — self-computed linkage is mandatory.
+    const computed = computeValueHash(chain.closed.checkout_jwt, opts.sdAlg);
+    if (computed !== chain.closed.checkout_hash) {
+        violations.push(`Self-computed checkout_hash mismatch: hash(checkout_jwt)=${computed}, mandate checkout_hash=${chain.closed.checkout_hash}`);
+        return violations; // do not evaluate constraints against an unbound checkout
+    }
+    let checkout;
+    try {
+        checkout = extractCheckout(chain.closed.checkout_jwt);
+    }
+    catch (e) {
+        return [e.message];
+    }
+    violations.push(...checkCheckoutConstraints(chain.open, checkout));
+    if (opts.expectedCheckoutHash !== undefined && opts.expectedCheckoutHash !== chain.closed.checkout_hash) {
+        violations.push(`Checkout checkout_hash mismatch: expected ${opts.expectedCheckoutHash}, got ${chain.closed.checkout_hash}`);
+    }
+    return violations;
+}
+// ── Receipt reference ────────────────────────────────────────────────────────
+/** The closed-mandate leaf JWT of a chain (port of `get_closed_mandate_jwt`):
+ * the bare issuer JWT (no disclosures) of the final `~~`-separated segment.
+ *
+ * NOTE: this is for embedding/identifying the closed mandate. It is NOT the
+ * receipt-reference input — use `receiptReference()` for that. (AP2's SDK
+ * `get_closed_mandate_jwt` docstring suggests `sha256` of this string as the
+ * reference, but the AP2 spec (AUTH-17) defines the reference as `sd_hash` over
+ * the final SD-JWT *including disclosures*; we follow the spec. The two differ.)
+ */
+export function getClosedMandateJwt(presentationToken) {
+    const lastSegment = presentationToken.split("~~").at(-1);
+    return lastSegment.split("~", 1)[0];
+}
+/**
+ * Stable receipt `reference` for a chain (AUTH-17 / SPEC-6): the base64url hash
+ * of the FINAL SD-JWT in the chain, computed "in the same manner as `sd_hash`"
+ * — i.e. `sd_hash` over the last segment's canonical SD-JWT form (issuer JWT +
+ * disclosures). This is the spec-authoritative reference; it is deliberately
+ * NOT `sha256(getClosedMandateJwt(chain))` (see that function's note).
+ */
+export function receiptReference(presentationToken) {
+    const segments = presentationToken.split("~~");
+    const last = parseToken(canonicalChainSegment(segments.at(-1), segments.length - 1, segments.length));
+    return computeSdHash(last);
+}
+//# sourceMappingURL=chains.js.map

package/dist/ap2/chains.js.map

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

package/dist/ap2/constraints.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Payment-constraint evaluation — line-for-line port of AP2's
+ * `sdk/constraints.py` (commit e1ea56d). Each evaluator returns a list of
+ * violation messages ([] = satisfied). Violation strings match AP2's f-strings
+ * byte-for-byte where the inputs are reproducible (amounts, ids, names, dates);
+ * the few AP2 messages that embed a Python object `repr` (pisp / pre-set
+ * amount+instrument) are noted and use a readable JSON form instead — only the
+ * violation COUNT is asserted against AP2 for those.
+ *
+ * Closed-world rule (AUTH-15 / SPEC-39): an UNKNOWN constraint type MUST be
+ * treated as failing evaluation.
+ */
+import { type Checkout, type Merchant, type MandateContext, type OpenCheckoutMandate, type OpenPaymentMandate, type PaymentMandate } from "./types.js";
+interface EvalContext {
+    openCheckoutHash?: string;
+    mandateContext?: MandateContext;
+    /**
+     * Constraint types the caller requires to have been enforced on this mandate,
+     * e.g. `["payment.budget"]`.
+     *
+     * AP2 builds one evaluator per constraint PRESENT in the open mandate and never
+     * asserts which constraints ought to have been there, so a constraint withheld
+     * through selective disclosure produces no evaluator and no violation. An empty
+     * result therefore cannot distinguish "every constraint was evaluated and
+     * satisfied" from "nothing was evaluated". Declaring the set here makes the
+     * difference observable: a required constraint that is absent is reported
+     * rather than silently skipped.
+     *
+     * Opt-in and additive. Omit it and evaluation is byte-identical to AP2.
+     */
+    requiredConstraints?: string[];
+}
+/** Port of `merchant_matches`: id-first, else name+website (both non-empty). */
+export declare function merchantMatches(candidate: Merchant, target: Merchant): boolean;
+/** Port of `check_preset_payment_claims`: open mandate pre-set fields must be
+ * present unchanged in the closed mandate (SPEC-38 / step 2). */
+export declare function checkPresetPaymentClaims(open: OpenPaymentMandate, closed: PaymentMandate): string[];
+/**
+ * Verify a closed payment satisfies an open mandate's pre-set claims and
+ * constraints. Port of `check_payment_constraints`. Returns [] when satisfied.
+ */
+export declare function checkPaymentConstraints(open: OpenPaymentMandate, closed: PaymentMandate, ctx?: EvalContext): string[];
+/** Verify a checkout satisfies an open checkout mandate's constraints. Port of
+ * `check_checkout_constraints`. Returns [] when satisfied. */
+export declare function checkCheckoutConstraints(open: OpenCheckoutMandate, checkout: Checkout): string[];
+export {};
+//# sourceMappingURL=constraints.d.ts.map

package/dist/ap2/constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../../src/ap2/constraints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAKpB,UAAU,WAAW;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC;;;;;;;;;;;;;OAaG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAQ9E;AAkID;iEACiE;AACjE,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,kBAAkB,EAAE,MAAM,EAAE,cAAc,GAAG,MAAM,EAAE,CAenG;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,kBAAkB,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,GAAE,WAAgB,GAAG,MAAM,EAAE,CA8BzH;AA+BD;8DAC8D;AAC9D,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,mBAAmB,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAAE,CAMhG"}