@atlasauth/pca-acp 0.0.0-stage → 0.2.0

package/LICENSE

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

package/README.md

@@ -1,3 +1,65 @@
-# Temporary Holding Version
+# @atlasauth/pca-acp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Agentic Commerce Protocol (ACP) and x402 adapter for Proof-Carrying Authority (PCA). It mints an ACP-style delegated one-time payment token (a JWS bound to session, merchant, amount, currency and expiry) from a PCActn, and provides an x402 (HTTP 402) facilitator hook that only settles when the token and its backing proof verify.
+
+The PCActn's capability caveats gate issuance: minting is refused (`AcpAuthorityError`) if the requested amount, currency, merchant, category or human-present modality exceeds what the proof authorizes, or if the token would outlive the proof. The token carries the proof by reference (its digest), never its contents. For the AP2 Intent/Cart/Payment chain see `@atlasauth/pca-ap2`.
+
+## Install
+
+```sh
+npm i @atlasauth/pca-acp
+```
+
+Depends on `@atlasauth/pca` and `jose` (installed transitively).
+
+## Usage
+
+```ts
+import {
+  spendCapCaveat, merchantAllowCaveat,
+  mintDelegatedPaymentToken, verifyDelegatedPaymentToken,
+  x402Challenge, x402Settle, acpX402Verifier,
+} from '@atlasauth/pca-acp';
+
+// `grant` carries payment caveats, e.g. mintRoot({ ..., caveats: [spendCapCaveat(500, 'USD'),
+// merchantAllowCaveat(['acme'])] }); `pcActn` is a PCActn built from it with @atlasauth/pca.
+
+const token = await mintDelegatedPaymentToken(pcActn, {
+  amount: 100, currency: 'USD', merchant: 'acme', session: 'sess-1',
+  expiresAt: Date.now() + 10 * 60_000,
+  paymentMethod: { type: 'shared_payment_token', token: 'spt_abc' },
+  signingKey: privateKey,                 // jose KeyLike, Uint8Array or JWK; default alg EdDSA
+});
+// minting 900 against the 500 cap throws AcpAuthorityError
+
+// Settlement: check the token binding and re-verify the backing proof.
+await verifyDelegatedPaymentToken(token, {
+  expectedMerchant: 'acme', amount: 100, verifyKey: publicKey,
+  pcActn, grant, audience: 'my-rs',       // optional full proof re-verification
+}); // { ok: true, claims, pcaResult }
+
+// x402: answer with a 402 challenge, then gate settlement on the proof-bound token.
+const challenge = x402Challenge('/api/report', { amount: 100, currency: 'USDC', payTo: '0xabc' });
+const result = await x402Settle({ token, merchant: 'acme', amount: 100 }, {
+  verify: acpX402Verifier({ verifyKey: publicKey, pcActn, grant, audience: 'my-rs' }),
+  settle: async (payload, claims) => ({ charged: claims.amount }),   // your facilitator call
+}); // { settled: true, status: 200, receipt } or { settled: false, status: 402, reason }
+```
+
+Pass `expectedMerchant` and `amount` to `acpX402Verifier` from your own order data when you can; by default it reads them from the client's payload.
+
+## API
+
+- Caveats: `spendCapCaveat`, `merchantAllowCaveat`, `merchantCategoryCaveat`, `humanPresentCaveat`, `extractPaymentAuthority`, `checkPaymentAuthority`, `AcpAuthorityError`.
+- Tokens: `mintDelegatedPaymentToken`, `verifyDelegatedPaymentToken`.
+- x402: `x402Challenge`, `x402Settle`, `acpX402Verifier`.
+
+## Status
+
+Experimental. ACP and x402 are young protocols: the token and `accepts` field names are structural and should be validated against the current Stripe/OpenAI ACP and Coinbase x402 specs before production use. The x402 helpers perform no network I/O; verification and settlement are injected. Single use of a token (`jti`) is not tracked here, so the resource server must record used ids. The cryptography is unaudited.
+
+Source and issues: https://github.com/Atlas-Authorization/pca
+
+## License
+
+MIT - see LICENSE

package/dist/index.d.ts

@@ -0,0 +1,369 @@
+/**
+ * @atlasauth/pca-acp — Agentic Commerce Protocol (ACP) + x402 for PCA.
+ *
+ * ┌──────────────────────────────────────────────────────────────────────────────────────────────┐
+ * │  PCA GOVERNS. ACP mints the delegated one-time payment token. x402 (HTTP 402) is the pay rail.  │
+ * │  "Every payment mandate is a verifiable proof-carrying action."                                 │
+ * └──────────────────────────────────────────────────────────────────────────────────────────────┘
+ *
+ * ACP (the Agentic Commerce Protocol, OpenAI + Stripe, 2025) lets an agent complete a purchase inside a
+ * chat/agent surface. Its payment leg is the Delegated / Shared Payment Token: a one-time, scope-bound
+ * token the buyer's agent hands the merchant to pull a bounded amount for ONE checkout
+ * (session + merchant + amount + expiry). x402 (Coinbase's HTTP 402 "Payment Required" flow) is the
+ * other net-new rail: a resource server answers `402` with a payment challenge, the client pays, and
+ * the server settles.
+ *
+ * This module makes BOTH of those proof-carrying. A delegated payment token is minted FROM a PCActn and
+ * carries that proof's authority by reference (its digest); the PCA proof's capability caveats — the
+ * spend cap, the merchant/category allowlist, the human-present requirement — GATE issuance: a token is
+ * refused at mint when the requested amount / currency / merchant / category / modality exceeds what the
+ * proof authorizes. At settlement the token's session/merchant/amount/expiry binding is re-checked and
+ * the bound PCActn can be re-verified, failing closed on over-amount, wrong-merchant, expiry, or a proof
+ * that no longer matches.
+ *
+ * This is ACP + x402, NOT AP2. The AP2 Intent→Cart→Payment VDC chain is `@atlasauth/pca-ap2`; this
+ * package reuses that mandate vocabulary (MonetaryAmount / merchants / categories / human_present /
+ * PaymentMethod) for consistency but is a distinct, wire-compatible adapter, not a re-implementation.
+ *
+ * ────────────────────────────────────────────────────────────────────────────────────────────────
+ * HONEST CAVEAT — VERIFY BEFORE PRODUCTION WIRE USE
+ * ────────────────────────────────────────────────────────────────────────────────────────────────
+ * ACP and x402 are young and moving. The exact JSON field names of the Stripe Shared Payment Token and
+ * the Coinbase x402 `accepts` requirement object should be validated against their current specs before
+ * production. The AUTHORITY model here (mint-time caveat gating + settlement-time PCActn binding) is the
+ * stable, load-bearing contribution; the wire envelopes are structural and injectable.
+ */
+import { type Capability, type Caveat, type PCActn, type VerifyResult } from '@atlasauth/pca';
+import { type JWK, type KeyLike } from 'jose';
+/** The ACP delegated-payment-token shape this module emits (version pinned into the claims). */
+export declare const ACP_DELEGATED_TOKEN_VERSION: 1;
+/** The `typ` claim carried in a delegated payment token (identifies the envelope to a verifier). */
+export declare const ACP_DELEGATED_TOKEN_TYPE: "acp-delegated-payment";
+/** ISO-4217 currency + decimal value (use minor units in production to avoid float drift). */
+export interface MonetaryAmount {
+    currency: string;
+    value: number;
+}
+/** The payment instrument a delegated token authorizes. Mirrors the AP2 `PaymentMethod` shape. */
+export interface PaymentMethod {
+    /** e.g. `card`, `shared_payment_token`, `x402`, `crypto`. */
+    type: string;
+    display?: string;
+    /** Opaque token (e.g. a Stripe Shared Payment Token id); never a raw PAN. */
+    token?: string;
+}
+/** `{ type: 'max_amount', max, currency? }` — per-transaction spend ceiling (optionally currency-bound). */
+export declare const SPEND_CAP_CAVEAT: "max_amount";
+/** `{ type: 'merchant_allow', merchants: [...] }` — allowlisted merchant ids (absent ⇒ any merchant). */
+export declare const MERCHANT_ALLOW_CAVEAT: "merchant_allow";
+/** `{ type: 'merchant_category', categories: [...] }` — allowlisted MCC categories (absent ⇒ any). */
+export declare const MERCHANT_CATEGORY_CAVEAT: "merchant_category";
+/** `{ type: 'human_present', required: boolean }` — require a human-present modality for the charge. */
+export declare const HUMAN_PRESENT_CAVEAT: "human_present";
+export interface SpendCapCaveat extends Caveat {
+    type: typeof SPEND_CAP_CAVEAT;
+    max: number;
+    currency?: string;
+}
+export interface MerchantAllowCaveat extends Caveat {
+    type: typeof MERCHANT_ALLOW_CAVEAT;
+    merchants: string[];
+}
+export interface MerchantCategoryCaveat extends Caveat {
+    type: typeof MERCHANT_CATEGORY_CAVEAT;
+    categories: string[];
+}
+export interface HumanPresentCaveat extends Caveat {
+    type: typeof HUMAN_PRESENT_CAVEAT;
+    required: boolean;
+}
+/** Build a per-transaction spend-cap caveat `{ type: 'max_amount', max, currency? }`. */
+export declare function spendCapCaveat(max: number, currency?: string): SpendCapCaveat;
+/** Build a merchant-allowlist caveat `{ type: 'merchant_allow', merchants }`. */
+export declare function merchantAllowCaveat(merchants: string[]): MerchantAllowCaveat;
+/** Build a merchant-category (MCC) allowlist caveat `{ type: 'merchant_category', categories }`. */
+export declare function merchantCategoryCaveat(categories: string[]): MerchantCategoryCaveat;
+/** Build a human-present requirement caveat `{ type: 'human_present', required }`. */
+export declare function humanPresentCaveat(required?: boolean): HumanPresentCaveat;
+/** Thrown when a delegated payment token cannot be minted because the request exceeds the proof's authority. */
+export declare class AcpAuthorityError extends Error {
+    constructor(message: string);
+}
+/** The conjunction of all payment caveats on a proof's leaf capability. */
+export interface PaymentAuthority {
+    /** Tightest per-transaction spend cap, or undefined when unconstrained. */
+    maxAmount?: number;
+    /** Currency the spend cap is denominated in, or undefined when the cap is currency-agnostic. */
+    currency?: string;
+    /** Allowlisted merchant ids (intersection of every allowlist caveat), or `null` for "any merchant". */
+    merchants: string[] | null;
+    /** Allowlisted MCC categories (intersection), or `null` for "any category". */
+    categories: string[] | null;
+    /** True when any caveat requires the charge to be human-present. */
+    humanPresentRequired: boolean;
+}
+/**
+ * Collapse a leaf capability's cumulative caveat list into its effective payment authority. Payment
+ * caveats combine conjunctively (tightest cap, intersected allowlists, sticky human-present); a malformed
+ * PAYMENT caveat throws (fail closed); any non-payment caveat type is ignored. The order of caveats does
+ * not matter — the result is the same conjunction either way.
+ */
+export declare function extractPaymentAuthority(caveats: readonly Caveat[]): PaymentAuthority;
+/** A concrete purchase request, checked against a {@link PaymentAuthority}. */
+export interface PaymentRequest {
+    amount: number;
+    currency: string;
+    merchant: string;
+    /** The merchant's MCC category, when known (required only if the proof constrains categories). */
+    category?: string;
+    /** Whether a human is present/attesting for this charge (the ACP modality signal). */
+    humanPresent?: boolean;
+}
+/** The outcome of checking a purchase request against a proof's payment authority. */
+export interface AuthorityCheck {
+    ok: boolean;
+    reason?: string;
+}
+/**
+ * Check a concrete purchase request against the payment authority a PCActn carries. Pure and fail-closed:
+ * an over-cap amount, a currency the cap forbids, a merchant / category outside the allowlist, or a
+ * missing human-present signal the proof demands all return `{ ok: false }`.
+ */
+export declare function checkPaymentAuthority(authority: PaymentAuthority, request: PaymentRequest): AuthorityCheck;
+/** How a delegated payment token points back at the PCActn that authorized it (authority by reference). */
+export interface PcaAuthorityRef {
+    /** `pcactnDigest()` of the authorizing proof — the binding a verifier re-checks against the proof. */
+    digest: string;
+    /** The proof's audience (resource server / Atlas instance id). */
+    aud: string;
+    /** The proof's grant id. */
+    grant_ref: string;
+    /** The acting leaf capability holder (b64u public key). */
+    leaf_holder: string;
+    verb: string;
+    resource: string;
+    params_digest: string;
+}
+/** A key usable to sign/verify a delegated payment token. A plain JWK is imported; other forms pass through. */
+export type TokenKey = KeyLike | Uint8Array | JWK;
+/** The claims a delegated payment token carries (the JWS payload). One-time, scope-bound, proof-referenced. */
+export interface DelegatedPaymentClaims {
+    typ: typeof ACP_DELEGATED_TOKEN_TYPE;
+    ver: typeof ACP_DELEGATED_TOKEN_VERSION;
+    /** One-time id (a resource server tracks it to enforce single-use). */
+    jti: string;
+    /** The ACP checkout session this token is bound to. */
+    session: string;
+    /** The merchant this token may pay. */
+    merchant: string;
+    /** The maximum amount this token authorizes (minor-unit-safe decimal). */
+    amount: number;
+    currency: string;
+    /** Issued-at (epoch ms). */
+    iat: number;
+    /** Expiry (epoch ms). */
+    exp: number;
+    paymentMethod: PaymentMethod;
+    /** The ACP human-present modality signal for this charge. */
+    humanPresent: boolean;
+    /** The merchant category, when supplied at mint. */
+    category?: string;
+    /** Optional issuer id of the minting party (agent platform / facilitator). */
+    iss?: string;
+    /** The PCA authority this token carries by reference. */
+    pca: PcaAuthorityRef;
+}
+/** Options for {@link mintDelegatedPaymentToken}. */
+export interface MintOptions {
+    /** The amount to authorize (the token's ceiling for this one checkout). */
+    amount: number;
+    currency: string;
+    /** The merchant the token may pay. */
+    merchant: string;
+    /** The ACP checkout session id the token is bound to. */
+    session: string;
+    /** Token expiry (epoch ms). Must be in the future and not outlive the authorizing proof's `exp`. */
+    expiresAt: number;
+    paymentMethod: PaymentMethod;
+    /** The JWS signing key (the minting party's key). Required to produce the token. */
+    signingKey: TokenKey;
+    /** JWS algorithm (default `'EdDSA'`). */
+    alg?: string;
+    /** Merchant category (MCC), required only when the proof constrains categories. */
+    category?: string;
+    /** The human-present modality to stamp; also satisfies a `human_present` caveat when `true`. */
+    humanPresent?: boolean;
+    /** Issuer id to stamp into the claims. */
+    issuer?: string;
+    /** JWS `kid` header (set it when verifiers resolve the key from a JWKS). */
+    kid?: string;
+    /** Explicit one-time id. Default: a deterministic digest of the binding + proof digest. */
+    jti?: string;
+    /** Issued-at clock (epoch ms). Default `Date.now()`. */
+    now?: number;
+}
+/**
+ * Mint a one-time ACP delegated payment token (a JWS) FROM a PCActn. The token is bound to
+ * session + merchant + amount + currency + expiry and carries the proof's authority BY REFERENCE
+ * (`pca.digest`). The PCActn's capability caveats gate issuance: the request is checked against the
+ * proof's {@link PaymentAuthority} and the mint is REFUSED (throws {@link AcpAuthorityError}) when the
+ * amount / currency / merchant / category / modality exceeds it, or when the requested expiry is in the
+ * past or would outlive the proof. The token never re-exposes the proof's contents — only the digest.
+ */
+export declare function mintDelegatedPaymentToken(pcActn: PCActn, opts: MintOptions): Promise<string>;
+/** Options for {@link verifyDelegatedPaymentToken}. */
+export interface VerifyTokenOptions {
+    /** The expected merchant the token must authorize. */
+    expectedMerchant: string;
+    /** The amount the caller intends to settle. Fails closed when it exceeds the token's authorized amount. */
+    amount: number;
+    /** The JWS verification key. */
+    verifyKey: TokenKey;
+    /** JWS algorithm (default `'EdDSA'`). */
+    alg?: string;
+    /** Verification clock (epoch ms). Default `Date.now()`. */
+    now?: number;
+    /** The session the token must be bound to, when the caller wants it checked. */
+    expectedSession?: string;
+    /** Expected settlement currency, when the caller wants it checked. */
+    expectedCurrency?: string;
+    /**
+     * The authorizing PCActn. When supplied, its `pcactnDigest()` must equal the token's `pca.digest`
+     * (proof-binding). When `grant` is ALSO supplied, the proof is additionally re-verified end-to-end.
+     */
+    pcActn?: PCActn;
+    /** The grant to re-verify `pcActn` against (enables a full `verifyPCActnCore` pass). */
+    grant?: Capability;
+    /** This verifier's audience for the full `verifyPCActnCore` pass (see the core's fail-closed rule). */
+    audience?: string | null;
+}
+/** The outcome of verifying a delegated payment token. */
+export interface TokenVerification {
+    ok: boolean;
+    reason?: string;
+    /** The verified claims (present only on success, or when the JWS verified but a binding check failed). */
+    claims?: DelegatedPaymentClaims;
+    /** The full PCActn verify result, when a re-verify was requested. */
+    pcaResult?: VerifyResult;
+}
+/**
+ * Verify a delegated payment token at settlement. Checks the JWS signature, then the token binding:
+ * merchant must equal `expectedMerchant`, the amount being settled must not exceed the token's authorized
+ * amount, the token must not be expired, and (when asked) the session / currency must match. When a
+ * `pcActn` is supplied its digest must equal the token's `pca.digest`; with a `grant` it is re-verified
+ * end-to-end. Fails CLOSED on every mismatch.
+ */
+export declare function verifyDelegatedPaymentToken(token: string, opts: VerifyTokenOptions): Promise<TokenVerification>;
+/** A single x402 payment requirement (the server's `accepts` entry). Structural; check against the x402 spec. */
+export interface X402Requirement {
+    scheme: string;
+    network: string;
+    maxAmountRequired: string;
+    resource: string;
+    description: string;
+    payTo: string;
+    asset: string;
+    mimeType: string;
+}
+/** The HTTP 402 challenge a resource server returns to demand payment. */
+export interface X402Challenge {
+    status: 402;
+    headers: Record<string, string>;
+    body: {
+        x402Version: 1;
+        accepts: X402Requirement[];
+        error?: string;
+    };
+}
+/** Options for {@link x402Challenge}. */
+export interface X402ChallengeOptions {
+    amount: number;
+    currency?: string;
+    /** The settlement network (e.g. an x402 chain id). Default `base-sepolia`. */
+    network?: string;
+    /** Payee address / account. */
+    payTo?: string;
+    description?: string;
+    /** Payment scheme. Default `exact`. */
+    scheme?: string;
+    mimeType?: string;
+    /** An error reason to surface alongside the challenge (e.g. on a rejected prior attempt). */
+    error?: string;
+}
+/**
+ * Build the HTTP 402 `Payment Required` challenge for a protected resource — the server's `accepts`
+ * payment requirement plus the `402` status. Structural only; no network. (Field names follow the
+ * public x402 shape and should be validated against the x402 spec before production.)
+ */
+export declare function x402Challenge(resource: string, opts: X402ChallengeOptions): X402Challenge;
+/** The client's x402 payment payload (the decoded `X-PAYMENT`). Carries the delegated payment token. */
+export interface X402PaymentPayload {
+    x402Version?: number;
+    scheme?: string;
+    network?: string;
+    /** The ACP delegated payment token (a JWS) proving proof-carrying authority for this charge. */
+    token: string;
+    /** The merchant the client is paying (checked against the token). */
+    merchant?: string;
+    /** The amount the client intends to settle (checked against the token). */
+    amount?: number;
+    resource?: string;
+    [k: string]: unknown;
+}
+/** The outcome an injected x402 verifier returns. */
+export interface X402VerifyResult {
+    ok: boolean;
+    reason?: string;
+    /** The verified token claims, when the payment verified. */
+    claims?: DelegatedPaymentClaims;
+}
+/** An injectable function that verifies an x402 payment payload (fed a verified PCActn-bound token). */
+export type X402Verify = (payload: X402PaymentPayload) => X402VerifyResult | Promise<X402VerifyResult>;
+/** An injectable settlement step run once payment is verified (e.g. a facilitator call). No network here. */
+export type X402Settler = (payload: X402PaymentPayload, claims: DelegatedPaymentClaims) => unknown | Promise<unknown>;
+/** Options for {@link x402Settle} — the injected verify (required) and optional settlement step. */
+export interface X402SettleOptions {
+    verify: X402Verify;
+    /** Optional settlement step run only after `verify` passes; its return value becomes the `receipt`. */
+    settle?: X402Settler;
+}
+/** The outcome of an x402 settlement attempt. */
+export interface X402SettleResult {
+    settled: boolean;
+    status: number;
+    reason?: string;
+    claims?: DelegatedPaymentClaims;
+    receipt?: unknown;
+}
+/**
+ * Gate an x402 settlement on a verified, PCActn-bound payment. Runs the injected `verify` over the
+ * client's payment payload; on failure it REFUSES with a fresh `402` (fail closed), on success it
+ * optionally runs the injected `settle` step and returns the receipt. The verify/settle steps are
+ * injectable so this composes with {@link verifyDelegatedPaymentToken} (see {@link acpX402Verifier})
+ * without this module performing any network itself.
+ */
+export declare function x402Settle(payload: X402PaymentPayload, opts: X402SettleOptions): Promise<X402SettleResult>;
+/** Options for {@link acpX402Verifier}. */
+export interface AcpX402VerifierOptions {
+    /** The JWS verification key for the delegated payment token. */
+    verifyKey: TokenKey;
+    alg?: string;
+    now?: number;
+    /** Override the expected merchant (default: the payload's `merchant`). */
+    expectedMerchant?: string;
+    /** Override the settlement amount (default: the payload's `amount`). */
+    amount?: number;
+    expectedSession?: string;
+    expectedCurrency?: string;
+    /** The authorizing proof to re-check the token against (digest, and end-to-end with `grant`). */
+    pcActn?: PCActn;
+    grant?: Capability;
+    audience?: string | null;
+}
+/**
+ * Adapt {@link verifyDelegatedPaymentToken} into an {@link X402Verify} for {@link x402Settle}: it reads
+ * the delegated payment token (and, by default, the merchant + amount the client claims) from the x402
+ * payload and verifies the token's binding + bound proof. This is the glue that makes the
+ * 402 → pay-with-proof → settle flow proof-carrying end to end.
+ */
+export declare function acpX402Verifier(opts: AcpX402VerifierOptions): X402Verify;

package/dist/index.js

@@ -0,0 +1,478 @@
+"use strict";
+/**
+ * @atlasauth/pca-acp — Agentic Commerce Protocol (ACP) + x402 for PCA.
+ *
+ * ┌──────────────────────────────────────────────────────────────────────────────────────────────┐
+ * │  PCA GOVERNS. ACP mints the delegated one-time payment token. x402 (HTTP 402) is the pay rail.  │
+ * │  "Every payment mandate is a verifiable proof-carrying action."                                 │
+ * └──────────────────────────────────────────────────────────────────────────────────────────────┘
+ *
+ * ACP (the Agentic Commerce Protocol, OpenAI + Stripe, 2025) lets an agent complete a purchase inside a
+ * chat/agent surface. Its payment leg is the Delegated / Shared Payment Token: a one-time, scope-bound
+ * token the buyer's agent hands the merchant to pull a bounded amount for ONE checkout
+ * (session + merchant + amount + expiry). x402 (Coinbase's HTTP 402 "Payment Required" flow) is the
+ * other net-new rail: a resource server answers `402` with a payment challenge, the client pays, and
+ * the server settles.
+ *
+ * This module makes BOTH of those proof-carrying. A delegated payment token is minted FROM a PCActn and
+ * carries that proof's authority by reference (its digest); the PCA proof's capability caveats — the
+ * spend cap, the merchant/category allowlist, the human-present requirement — GATE issuance: a token is
+ * refused at mint when the requested amount / currency / merchant / category / modality exceeds what the
+ * proof authorizes. At settlement the token's session/merchant/amount/expiry binding is re-checked and
+ * the bound PCActn can be re-verified, failing closed on over-amount, wrong-merchant, expiry, or a proof
+ * that no longer matches.
+ *
+ * This is ACP + x402, NOT AP2. The AP2 Intent→Cart→Payment VDC chain is `@atlasauth/pca-ap2`; this
+ * package reuses that mandate vocabulary (MonetaryAmount / merchants / categories / human_present /
+ * PaymentMethod) for consistency but is a distinct, wire-compatible adapter, not a re-implementation.
+ *
+ * ────────────────────────────────────────────────────────────────────────────────────────────────
+ * HONEST CAVEAT — VERIFY BEFORE PRODUCTION WIRE USE
+ * ────────────────────────────────────────────────────────────────────────────────────────────────
+ * ACP and x402 are young and moving. The exact JSON field names of the Stripe Shared Payment Token and
+ * the Coinbase x402 `accepts` requirement object should be validated against their current specs before
+ * production. The AUTHORITY model here (mint-time caveat gating + settlement-time PCActn binding) is the
+ * stable, load-bearing contribution; the wire envelopes are structural and injectable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcpAuthorityError = exports.HUMAN_PRESENT_CAVEAT = exports.MERCHANT_CATEGORY_CAVEAT = exports.MERCHANT_ALLOW_CAVEAT = exports.SPEND_CAP_CAVEAT = exports.ACP_DELEGATED_TOKEN_TYPE = exports.ACP_DELEGATED_TOKEN_VERSION = void 0;
+exports.spendCapCaveat = spendCapCaveat;
+exports.merchantAllowCaveat = merchantAllowCaveat;
+exports.merchantCategoryCaveat = merchantCategoryCaveat;
+exports.humanPresentCaveat = humanPresentCaveat;
+exports.extractPaymentAuthority = extractPaymentAuthority;
+exports.checkPaymentAuthority = checkPaymentAuthority;
+exports.mintDelegatedPaymentToken = mintDelegatedPaymentToken;
+exports.verifyDelegatedPaymentToken = verifyDelegatedPaymentToken;
+exports.x402Challenge = x402Challenge;
+exports.x402Settle = x402Settle;
+exports.acpX402Verifier = acpX402Verifier;
+const pca_1 = require("@atlasauth/pca");
+const jose_1 = require("jose");
+// ===================================================================================================
+// Version + token type
+// ===================================================================================================
+/** The ACP delegated-payment-token shape this module emits (version pinned into the claims). */
+exports.ACP_DELEGATED_TOKEN_VERSION = 1;
+/** The `typ` claim carried in a delegated payment token (identifies the envelope to a verifier). */
+exports.ACP_DELEGATED_TOKEN_TYPE = 'acp-delegated-payment';
+// ===================================================================================================
+// Payment caveat vocabulary (what the PCA proof's capability chain carries to bound a purchase)
+// ===================================================================================================
+//
+// The PCA capability chain is attenuating and append-only (see @atlasauth/pca `capability.ts`): a child
+// hop can only ADD caveats, never drop or widen one. The leaf hop therefore carries the full cumulative
+// caveat list, and these payment caveats COMBINE CONJUNCTIVELY (the tightest spend cap wins; merchant /
+// category allowlists INTERSECT; any `human_present` requirement sticks). A malformed PAYMENT caveat
+// fails closed; caveats of any other type (ttl, scope, …) are ignored here.
+/** `{ type: 'max_amount', max, currency? }` — per-transaction spend ceiling (optionally currency-bound). */
+exports.SPEND_CAP_CAVEAT = 'max_amount';
+/** `{ type: 'merchant_allow', merchants: [...] }` — allowlisted merchant ids (absent ⇒ any merchant). */
+exports.MERCHANT_ALLOW_CAVEAT = 'merchant_allow';
+/** `{ type: 'merchant_category', categories: [...] }` — allowlisted MCC categories (absent ⇒ any). */
+exports.MERCHANT_CATEGORY_CAVEAT = 'merchant_category';
+/** `{ type: 'human_present', required: boolean }` — require a human-present modality for the charge. */
+exports.HUMAN_PRESENT_CAVEAT = 'human_present';
+/** Build a per-transaction spend-cap caveat `{ type: 'max_amount', max, currency? }`. */
+function spendCapCaveat(max, currency) {
+    return currency !== undefined ? { type: exports.SPEND_CAP_CAVEAT, max, currency } : { type: exports.SPEND_CAP_CAVEAT, max };
+}
+/** Build a merchant-allowlist caveat `{ type: 'merchant_allow', merchants }`. */
+function merchantAllowCaveat(merchants) {
+    return { type: exports.MERCHANT_ALLOW_CAVEAT, merchants: [...merchants] };
+}
+/** Build a merchant-category (MCC) allowlist caveat `{ type: 'merchant_category', categories }`. */
+function merchantCategoryCaveat(categories) {
+    return { type: exports.MERCHANT_CATEGORY_CAVEAT, categories: [...categories] };
+}
+/** Build a human-present requirement caveat `{ type: 'human_present', required }`. */
+function humanPresentCaveat(required = true) {
+    return { type: exports.HUMAN_PRESENT_CAVEAT, required };
+}
+// ===================================================================================================
+// Errors
+// ===================================================================================================
+/** Thrown when a delegated payment token cannot be minted because the request exceeds the proof's authority. */
+class AcpAuthorityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AcpAuthorityError';
+    }
+}
+exports.AcpAuthorityError = AcpAuthorityError;
+function asStringArray(v, label) {
+    if (!Array.isArray(v) || !v.every((x) => typeof x === 'string')) {
+        throw new AcpAuthorityError(`malformed ${label} caveat: expected a string[] (fail closed)`);
+    }
+    return v;
+}
+/**
+ * Collapse a leaf capability's cumulative caveat list into its effective payment authority. Payment
+ * caveats combine conjunctively (tightest cap, intersected allowlists, sticky human-present); a malformed
+ * PAYMENT caveat throws (fail closed); any non-payment caveat type is ignored. The order of caveats does
+ * not matter — the result is the same conjunction either way.
+ */
+function extractPaymentAuthority(caveats) {
+    let maxAmount;
+    let currency;
+    let merchants = null;
+    let categories = null;
+    let humanPresentRequired = false;
+    for (const c of caveats) {
+        switch (c.type) {
+            case exports.SPEND_CAP_CAVEAT: {
+                const max = c.max;
+                if (typeof max !== 'number' || !Number.isFinite(max) || max < 0) {
+                    throw new AcpAuthorityError('malformed max_amount caveat: max must be a finite number >= 0 (fail closed)');
+                }
+                maxAmount = maxAmount === undefined ? max : Math.min(maxAmount, max);
+                const cur = c.currency;
+                if (cur !== undefined) {
+                    if (typeof cur !== 'string' || cur.length === 0) {
+                        throw new AcpAuthorityError('malformed max_amount caveat: currency must be a non-empty string (fail closed)');
+                    }
+                    if (currency !== undefined && currency !== cur) {
+                        throw new AcpAuthorityError(`conflicting spend-cap currencies "${currency}" vs "${cur}" (fail closed)`);
+                    }
+                    currency = cur;
+                }
+                break;
+            }
+            case exports.MERCHANT_ALLOW_CAVEAT: {
+                const list = asStringArray(c.merchants, 'merchant_allow');
+                merchants = merchants === null ? [...new Set(list)] : merchants.filter((m) => list.includes(m));
+                break;
+            }
+            case exports.MERCHANT_CATEGORY_CAVEAT: {
+                const list = asStringArray(c.categories, 'merchant_category');
+                categories = categories === null ? [...new Set(list)] : categories.filter((m) => list.includes(m));
+                break;
+            }
+            case exports.HUMAN_PRESENT_CAVEAT: {
+                const req = c.required;
+                if (typeof req !== 'boolean') {
+                    throw new AcpAuthorityError('malformed human_present caveat: required must be a boolean (fail closed)');
+                }
+                humanPresentRequired = humanPresentRequired || req;
+                break;
+            }
+            default:
+                break; // non-payment caveat (ttl, scope, resource, …) — not this adapter's concern
+        }
+    }
+    return {
+        ...(maxAmount !== undefined ? { maxAmount } : {}),
+        ...(currency !== undefined ? { currency } : {}),
+        merchants,
+        categories,
+        humanPresentRequired,
+    };
+}
+/** The leaf (acting) capability of a proof's chain. */
+function leafCapability(pcActn) {
+    const chain = pcActn.cap_chain;
+    if (!Array.isArray(chain) || chain.length === 0) {
+        throw new AcpAuthorityError('PCActn carries no capability chain (fail closed)');
+    }
+    const leaf = chain[chain.length - 1];
+    if (leaf === undefined)
+        throw new AcpAuthorityError('PCActn capability chain has no leaf (fail closed)');
+    return leaf;
+}
+/**
+ * Check a concrete purchase request against the payment authority a PCActn carries. Pure and fail-closed:
+ * an over-cap amount, a currency the cap forbids, a merchant / category outside the allowlist, or a
+ * missing human-present signal the proof demands all return `{ ok: false }`.
+ */
+function checkPaymentAuthority(authority, request) {
+    if (typeof request.amount !== 'number' || !Number.isFinite(request.amount) || request.amount <= 0) {
+        return { ok: false, reason: 'amount must be a finite number > 0' };
+    }
+    if (typeof request.currency !== 'string' || request.currency.length === 0) {
+        return { ok: false, reason: 'currency must be a non-empty string' };
+    }
+    if (typeof request.merchant !== 'string' || request.merchant.length === 0) {
+        return { ok: false, reason: 'merchant must be a non-empty string' };
+    }
+    if (authority.currency !== undefined && authority.currency !== request.currency) {
+        return { ok: false, reason: `currency "${request.currency}" is not the authorized currency "${authority.currency}"` };
+    }
+    if (authority.maxAmount !== undefined && request.amount > authority.maxAmount) {
+        return { ok: false, reason: `amount ${request.amount} exceeds the authorized spend cap ${authority.maxAmount}` };
+    }
+    if (authority.merchants !== null && !authority.merchants.includes(request.merchant)) {
+        return { ok: false, reason: `merchant "${request.merchant}" is not in the authorized allowlist` };
+    }
+    if (authority.categories !== null) {
+        if (request.category === undefined) {
+            return { ok: false, reason: 'the proof constrains merchant categories but no category was supplied' };
+        }
+        if (!authority.categories.includes(request.category)) {
+            return { ok: false, reason: `category "${request.category}" is not in the authorized allowlist` };
+        }
+    }
+    if (authority.humanPresentRequired && request.humanPresent !== true) {
+        return { ok: false, reason: 'the proof requires a human-present charge but humanPresent was not asserted' };
+    }
+    return { ok: true };
+}
+function authorityRef(pcActn) {
+    const leaf = leafCapability(pcActn);
+    return {
+        digest: (0, pca_1.pcactnDigest)(pcActn),
+        aud: pcActn.aud,
+        grant_ref: pcActn.grant_ref,
+        leaf_holder: leaf.holder,
+        verb: pcActn.action.verb,
+        resource: pcActn.action.resource,
+        params_digest: pcActn.action.params_digest,
+    };
+}
+function isJwk(k) {
+    return typeof k === 'object' && k !== null && !(k instanceof Uint8Array) && 'kty' in k;
+}
+/**
+ * Mint a one-time ACP delegated payment token (a JWS) FROM a PCActn. The token is bound to
+ * session + merchant + amount + currency + expiry and carries the proof's authority BY REFERENCE
+ * (`pca.digest`). The PCActn's capability caveats gate issuance: the request is checked against the
+ * proof's {@link PaymentAuthority} and the mint is REFUSED (throws {@link AcpAuthorityError}) when the
+ * amount / currency / merchant / category / modality exceeds it, or when the requested expiry is in the
+ * past or would outlive the proof. The token never re-exposes the proof's contents — only the digest.
+ */
+async function mintDelegatedPaymentToken(pcActn, opts) {
+    const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+    // 1. Gate issuance on the proof's authority (fail closed on an over-authority request).
+    const authority = extractPaymentAuthority(leafCapability(pcActn).caveats);
+    const check = checkPaymentAuthority(authority, {
+        amount: opts.amount,
+        currency: opts.currency,
+        merchant: opts.merchant,
+        ...(opts.category !== undefined ? { category: opts.category } : {}),
+        ...(opts.humanPresent !== undefined ? { humanPresent: opts.humanPresent } : {}),
+    });
+    if (!check.ok)
+        throw new AcpAuthorityError(`refused: ${check.reason ?? 'request exceeds the proof authority'}`);
+    // 2. Expiry binding: the token must expire in the future and never outlive the proof that authorized it.
+    if (!Number.isFinite(opts.expiresAt))
+        throw new AcpAuthorityError('refused: expiresAt must be a finite epoch-ms timestamp');
+    if (opts.expiresAt <= now)
+        throw new AcpAuthorityError('refused: expiresAt is not in the future');
+    if (opts.expiresAt > pcActn.exp) {
+        throw new AcpAuthorityError(`refused: token expiry ${opts.expiresAt} would outlive the proof's exp ${pcActn.exp}`);
+    }
+    if (!opts.session)
+        throw new AcpAuthorityError('refused: a session id is required');
+    const pca = authorityRef(pcActn);
+    const jti = opts.jti ??
+        (0, pca_1.pcactnDigest)({
+            ...pcActn,
+            // Derive a stable one-time id from the proof digest + the token binding (not a real PCActn; just a hash seed).
+            nonce: `acp:${opts.session}:${opts.merchant}:${opts.amount}:${opts.currency}:${opts.expiresAt}:${pca.digest}`,
+        });
+    const claims = {
+        typ: exports.ACP_DELEGATED_TOKEN_TYPE,
+        ver: exports.ACP_DELEGATED_TOKEN_VERSION,
+        jti,
+        session: opts.session,
+        merchant: opts.merchant,
+        amount: opts.amount,
+        currency: opts.currency,
+        iat: now,
+        exp: opts.expiresAt,
+        paymentMethod: { ...opts.paymentMethod },
+        humanPresent: opts.humanPresent === true,
+        ...(opts.category !== undefined ? { category: opts.category } : {}),
+        ...(opts.issuer !== undefined ? { iss: opts.issuer } : {}),
+        pca,
+    };
+    const alg = opts.alg ?? 'EdDSA';
+    const key = isJwk(opts.signingKey) ? await (0, jose_1.importJWK)(opts.signingKey, alg) : opts.signingKey;
+    const protectedHeader = {
+        alg,
+        typ: exports.ACP_DELEGATED_TOKEN_TYPE,
+        ...(opts.kid !== undefined ? { kid: opts.kid } : {}),
+    };
+    return new jose_1.CompactSign((0, pca_1.utf8)(JSON.stringify(claims))).setProtectedHeader(protectedHeader).sign(key);
+}
+function isPaymentMethod(v) {
+    return v !== null && typeof v === 'object' && typeof v.type === 'string';
+}
+function parseClaims(bytes) {
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const c = parsed;
+    if (c.typ !== exports.ACP_DELEGATED_TOKEN_TYPE || c.ver !== exports.ACP_DELEGATED_TOKEN_VERSION)
+        return null;
+    if (typeof c.jti !== 'string' ||
+        typeof c.session !== 'string' ||
+        typeof c.merchant !== 'string' ||
+        typeof c.amount !== 'number' ||
+        typeof c.currency !== 'string' ||
+        typeof c.iat !== 'number' ||
+        typeof c.exp !== 'number' ||
+        typeof c.humanPresent !== 'boolean' ||
+        !isPaymentMethod(c.paymentMethod)) {
+        return null;
+    }
+    const pcaRaw = c.pca;
+    if (pcaRaw === null || typeof pcaRaw !== 'object' || Array.isArray(pcaRaw))
+        return null;
+    const p = pcaRaw;
+    if (typeof p.digest !== 'string' ||
+        typeof p.aud !== 'string' ||
+        typeof p.grant_ref !== 'string' ||
+        typeof p.leaf_holder !== 'string' ||
+        typeof p.verb !== 'string' ||
+        typeof p.resource !== 'string' ||
+        typeof p.params_digest !== 'string') {
+        return null;
+    }
+    // Shape validated field-by-field above; assemble the typed view.
+    return parsed;
+}
+/**
+ * Verify a delegated payment token at settlement. Checks the JWS signature, then the token binding:
+ * merchant must equal `expectedMerchant`, the amount being settled must not exceed the token's authorized
+ * amount, the token must not be expired, and (when asked) the session / currency must match. When a
+ * `pcActn` is supplied its digest must equal the token's `pca.digest`; with a `grant` it is re-verified
+ * end-to-end. Fails CLOSED on every mismatch.
+ */
+async function verifyDelegatedPaymentToken(token, opts) {
+    const alg = opts.alg ?? 'EdDSA';
+    const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+    // 1. JWS signature.
+    let claims;
+    try {
+        const key = isJwk(opts.verifyKey) ? await (0, jose_1.importJWK)(opts.verifyKey, alg) : opts.verifyKey;
+        const { payload } = await (0, jose_1.compactVerify)(token, key, { algorithms: [alg] });
+        claims = parseClaims(payload);
+    }
+    catch (e) {
+        return { ok: false, reason: `token signature did not verify: ${e.message}` };
+    }
+    if (claims === null)
+        return { ok: false, reason: 'token payload is not a well-formed delegated payment token' };
+    // 2. Binding checks (fail closed).
+    if (claims.merchant !== opts.expectedMerchant) {
+        return { ok: false, reason: `token merchant "${claims.merchant}" does not match expected "${opts.expectedMerchant}"`, claims };
+    }
+    if (typeof opts.amount !== 'number' || !Number.isFinite(opts.amount) || opts.amount <= 0) {
+        return { ok: false, reason: 'settlement amount must be a finite number > 0', claims };
+    }
+    if (opts.amount > claims.amount) {
+        return { ok: false, reason: `settlement amount ${opts.amount} exceeds the token's authorized amount ${claims.amount}`, claims };
+    }
+    if (now > claims.exp) {
+        return { ok: false, reason: 'the delegated payment token has expired', claims };
+    }
+    if (opts.expectedSession !== undefined && claims.session !== opts.expectedSession) {
+        return { ok: false, reason: `token session "${claims.session}" does not match expected "${opts.expectedSession}"`, claims };
+    }
+    if (opts.expectedCurrency !== undefined && claims.currency !== opts.expectedCurrency) {
+        return { ok: false, reason: `token currency "${claims.currency}" does not match expected "${opts.expectedCurrency}"`, claims };
+    }
+    // 3. Proof binding (optional): the token's digest must match the supplied PCActn.
+    if (opts.pcActn !== undefined) {
+        if ((0, pca_1.pcactnDigest)(opts.pcActn) !== claims.pca.digest) {
+            return { ok: false, reason: 'pcactn_digest mismatch: the supplied proof is not the one that minted this token', claims };
+        }
+        if (opts.grant !== undefined) {
+            const pcaResult = await (0, pca_1.verifyPCActnCore)(opts.pcActn, {
+                grant: opts.grant,
+                nowEpoch: now,
+                audience: opts.audience,
+            });
+            if (!pcaResult.allow) {
+                return { ok: false, reason: `bound proof failed to verify: ${pcaResult.reason ?? 'denied'}`, claims, pcaResult };
+            }
+            return { ok: true, claims, pcaResult };
+        }
+    }
+    return { ok: true, claims };
+}
+/**
+ * Build the HTTP 402 `Payment Required` challenge for a protected resource — the server's `accepts`
+ * payment requirement plus the `402` status. Structural only; no network. (Field names follow the
+ * public x402 shape and should be validated against the x402 spec before production.)
+ */
+function x402Challenge(resource, opts) {
+    const requirement = {
+        scheme: opts.scheme ?? 'exact',
+        network: opts.network ?? 'base-sepolia',
+        maxAmountRequired: String(opts.amount),
+        resource,
+        description: opts.description ?? `Payment required for ${resource}`,
+        payTo: opts.payTo ?? '',
+        asset: opts.currency ?? '',
+        mimeType: opts.mimeType ?? 'application/json',
+    };
+    return {
+        status: 402,
+        headers: { 'Content-Type': 'application/json' },
+        body: {
+            x402Version: 1,
+            accepts: [requirement],
+            ...(opts.error !== undefined ? { error: opts.error } : {}),
+        },
+    };
+}
+/**
+ * Gate an x402 settlement on a verified, PCActn-bound payment. Runs the injected `verify` over the
+ * client's payment payload; on failure it REFUSES with a fresh `402` (fail closed), on success it
+ * optionally runs the injected `settle` step and returns the receipt. The verify/settle steps are
+ * injectable so this composes with {@link verifyDelegatedPaymentToken} (see {@link acpX402Verifier})
+ * without this module performing any network itself.
+ */
+async function x402Settle(payload, opts) {
+    if (payload === null || typeof payload !== 'object' || typeof payload.token !== 'string') {
+        return { settled: false, status: 402, reason: 'x402 payment payload is missing a token' };
+    }
+    const v = await opts.verify(payload);
+    if (!v.ok) {
+        return { settled: false, status: 402, reason: v.reason ?? 'payment verification failed', ...(v.claims ? { claims: v.claims } : {}) };
+    }
+    if (v.claims === undefined) {
+        return { settled: false, status: 402, reason: 'verifier admitted the payment but returned no claims (fail closed)' };
+    }
+    const receipt = opts.settle ? await opts.settle(payload, v.claims) : undefined;
+    return { settled: true, status: 200, claims: v.claims, ...(receipt !== undefined ? { receipt } : {}) };
+}
+/**
+ * Adapt {@link verifyDelegatedPaymentToken} into an {@link X402Verify} for {@link x402Settle}: it reads
+ * the delegated payment token (and, by default, the merchant + amount the client claims) from the x402
+ * payload and verifies the token's binding + bound proof. This is the glue that makes the
+ * 402 → pay-with-proof → settle flow proof-carrying end to end.
+ */
+function acpX402Verifier(opts) {
+    return async (payload) => {
+        const merchant = opts.expectedMerchant ?? payload.merchant;
+        if (typeof merchant !== 'string' || merchant.length === 0) {
+            return { ok: false, reason: 'x402 payload has no merchant to check the token against' };
+        }
+        const amount = opts.amount ?? payload.amount;
+        if (typeof amount !== 'number') {
+            return { ok: false, reason: 'x402 payload has no amount to check the token against' };
+        }
+        const res = await verifyDelegatedPaymentToken(payload.token, {
+            expectedMerchant: merchant,
+            amount,
+            verifyKey: opts.verifyKey,
+            ...(opts.alg !== undefined ? { alg: opts.alg } : {}),
+            ...(opts.now !== undefined ? { now: opts.now } : {}),
+            ...(opts.expectedSession !== undefined ? { expectedSession: opts.expectedSession } : {}),
+            ...(opts.expectedCurrency !== undefined ? { expectedCurrency: opts.expectedCurrency } : {}),
+            ...(opts.pcActn !== undefined ? { pcActn: opts.pcActn } : {}),
+            ...(opts.grant !== undefined ? { grant: opts.grant } : {}),
+            ...(opts.audience !== undefined ? { audience: opts.audience } : {}),
+        });
+        return { ok: res.ok, ...(res.reason !== undefined ? { reason: res.reason } : {}), ...(res.claims ? { claims: res.claims } : {}) };
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@atlasauth/pca-acp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Agentic Commerce (ACP) + x402 adapter for PCA: mint an ACP delegated one-time payment token (bound to session+merchant+amount+expiry) AS a PCA proof, and an x402/HTTP-402 facilitator hook that gates settlement on a verified PCActn.",
+  "keywords": [
+    "agentic commerce",
+    "x402",
+    "payments",
+    "http 402",
+    "agent authorization",
+    "proof-carrying authority",
+    "pca",
+    "ai agents"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/Atlas-Authorization/pca#readme",
+  "bugs": {
+    "url": "https://github.com/Atlas-Authorization/pca/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Atlas-Authorization/pca.git",
+    "directory": "packages/pca-acp"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "jose": "^5.9.6",
+    "@atlasauth/pca": "0.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
 }