@zkp2p/zkp2p-attestation 3.0.0 → 3.1.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 3.1.0
+
+- Remove the retired preproduction hostname and PCR8 from bundled trust pins.
+- Add typed Venmo and PayPal dispute helpers for attested session encryption, `POST /dispute/verify`, and local `DisputeAttestation` verification. The helpers use the `ZKP2P DisputeVerifier` EIP-712 domain and `DisputeDetails` wire fields while keeping all extracted identifiers out of public params.
+
+## 3.0.1
+
+- Restore the generic Buyer TEE compact JWE for standalone identity capture while retaining the Alipay types added in 3.0.0. `callerAddress` remains required on `POST /identity` and in the signed typed data, but is no longer required by identity encryption helpers or nested inside encrypted session material.
+- Keep PayPal, Wise, and Alipay maker registration public without Privy bearer authentication, linked-wallet enforcement, an alternate endpoint, or a compatibility wire.
+
 ## 3.0.0
 
 - BREAKING: `/identity` and its package helpers now require normalized `callerAddress` inside session-material JWEs and require the encrypted address to match the outer request. Unbound identity envelopes are rejected; buyer TEE envelopes are unchanged.

package/README.md

@@ -1,6 +1,6 @@
 # @zkp2p/zkp2p-attestation
 
-Client-side verifier and encryptor for ZKP2P Nitro identity attestations, seller credential uploads, and buyer TEE session-material requests.
+Client-side verifier and encryptor for ZKP2P Nitro payment, dispute, identity, and seller-credential flows.
 
 The package runs in Chrome MV3 service workers, browser DOM contexts, React Native with a Web Crypto polyfill, and Node >= 20. Library entrypoints use `fetch`, `SubtleCrypto`, `crypto.getRandomValues`, and `Uint8Array`; they do not import `node:*` modules or use `Buffer`.
 
@@ -33,7 +33,7 @@ Environment defaults:
 | `staging` | `https://attestation-service-staging.zkp2p.xyz` | bundled staging pin |
 | `production` | `https://attestation-service.zkp2p.xyz` | bundled production pin |
 
-Callers can still pass `attestationServiceUrl` and `trust.expectedPcr8Hex` directly. Explicit trust pins always win. The preprod hostname is pinned to the isolated preprod enclave; it is not a production alias.
+Callers can still pass `attestationServiceUrl` and `trust.expectedPcr8Hex` directly. Explicit trust pins always win. Bundled trust is limited to the canonical staging and production hostnames.
 
 ## Fast Path
 
@@ -162,8 +162,35 @@ Per-platform session-material types require these headers using the canonical na
 additional captured headers. Captured request bodies are session material because they can contain sensitive data and
 are encrypted before being sent to the service.
 
-Identity requests use the same attested upload key as buyer TEE, but use a caller-bound plaintext envelope. The typed
-helper normalizes `callerAddress`, encrypts it together with captured session material, posts
+Dispute verification uses the same attested key and compact JWE shape. The complete raw email stays encrypted, and all
+payment, dispute, and amount fields come from its authenticated contents rather than public params.
+
+```ts
+const dispute = await nitro.verifyDispute({
+  platform: "venmo",
+  actionType: "dispute_venmo",
+  sessionMaterial: { rawEmail: completeRfc5322Email },
+  params: {},
+  chainId,
+  intentHash,
+});
+
+const verifiedDispute = verifyDisputeAttestation(dispute, {
+  trustedSigners,
+  expectedPlatform: "venmo",
+  expectedActionType: "dispute_venmo",
+  expectedDomain: { chainId, verifyingContract: disputeVerifier },
+  expectedIntentHash: intentHash,
+});
+```
+
+Venmo uses `dispute_venmo`; PayPal uses `dispute_paypal`. Both accept only `{ rawEmail }` encrypted session material
+and `{}` public params. `verifyDisputeAttestation` checks the DisputeVerifier EIP-712 domain, the same trusted
+attestation-service witnesses used by payment and identity, the request intent, the signed data hash, and exact parity
+between `disputeDetails` and `encodedDisputeDetails`.
+
+Identity requests use the same attested upload key and compact JWE plaintext shape as buyer TEE, but with a narrower
+platform/action matrix. The typed helper encrypts captured session material, posts
 `{ platform, actionType, callerAddress, encryptedSessionMaterial, params }` to `POST /identity`, unwraps the service response, and
 returns an `IdentityAttestationOutput`. `verifyIdentityAttestation` checks the EIP-712 signature, trusted signer,
 platform/action binding, expected caller address, expected payee hash, canonical identity `dataHash`, and `validUntil`,
@@ -201,7 +228,7 @@ Identity platform matrix:
 | `cashapp` | `register_cashapp` | `sessionCookie`, `requestPayload`, optional `requestHeaders` | `{}` |
 | `alipay` | `register_alipay` | `Cookie` | `{}` |
 
-This matrix is intentionally limited to the caller-bound `POST /identity` request flow. A Monobank seller credential
+This matrix is intentionally limited to the public `POST /identity` request flow. A Monobank seller credential
 upload can additionally return a typed `IdentityAttestationOutputFor<"monobank">` with `register_monobank`; consumers
 can pass that response directly to `verifyIdentityAttestation`, but cannot request it through `POST /identity`.
 
@@ -215,7 +242,9 @@ For Cash App identity, pass the replayable Cash App session cookie as `sessionMa
 
 For Alipay identity, pass a replayable `Cookie` header. The service fetches the authenticated account page and signs
 the historical transfer-recipient preimage: normalized recipient name concatenated directly with the redacted,
-lowercased email. The full normalized email is returned as `identity.username` for Curator binding.
+lowercased email. CJK names use their final CJK character to match Alipay's masked transfer detail; non-CJK names keep
+the existing token normalization. The normalized full email remains `identity.username`; the authenticated account's
+16-digit PID is returned as `identity.metadata.alipayPid` for payment routing.
 
 Buyer TEE and identity expose discriminated unions keyed by `platform` and `actionType`, including per-platform
 `params`, so invalid pairings fail during TypeScript compilation. Seller credential upload keeps its existing
@@ -258,17 +287,26 @@ const encryptedSessionMaterial = await nitro.encryptIdentitySessionMaterial({
   key: verified.attestedSellerUploadKey,
   platform: "paypal",
   actionType: "register_paypal",
-  callerAddress: "0x0000000000000000000000000000000000000002",
   sessionMaterial: {
     Cookie: "<captured-cookie-header>",
   },
 });
 ```
 
-Identity helpers emit `{ platform, actionType, sessionMaterial: { callerAddress, sessionMaterial },
-boundPubKeySha256 }` inside the compact JWE. The service requires the encrypted, normalized address to exactly match
-the outer request address before any provider request or signature. Identity JWEs created without this binding are
-rejected and must be regenerated. Buyer TEE envelopes retain their existing wire shape.
+Identity helpers emit `{ platform, actionType, sessionMaterial, boundPubKeySha256 }` inside the compact JWE, exactly
+like buyer TEE capture. The outer `callerAddress` is required by `POST /identity` and included in the signed typed data,
+but is not encrypted into or authenticated by the session envelope.
+
+For dispute flows with a cached attestation:
+
+```ts
+const encryptedSessionMaterial = await nitro.encryptDisputeSessionMaterial({
+  key: verified.attestedSellerUploadKey,
+  platform: "paypal",
+  actionType: "dispute_paypal",
+  sessionMaterial: { rawEmail: completeRfc5322Email },
+});
+```
 
 The attested SPKI is stable within one enclave process. If the enclave restarts, cached keys become stale and upload decrypt will fail; fetch a fresh attestation for a new session.
 
@@ -292,18 +330,23 @@ Any conforming `SubtleCrypto` works. The package does not require `Buffer`.
 ```ts
 import {
   createEncryptedBuyerTeeSessionMaterial,
+  createEncryptedDisputeSessionMaterial,
   createEncryptedIdentitySessionMaterial,
   createEncryptedSellerCredentialUpload,
   encryptBuyerTeeSessionMaterial,
+  encryptDisputeSessionMaterial,
   encryptIdentitySessionMaterial,
   encryptSellerCredentialUpload,
   fetchAndVerifyAttestation,
   getUnifiedPaymentVerifierDomainSeparator,
+  getDisputeVerifierDomainSeparator,
   hashUtf8,
   requestIdentityAttestation,
   uploadSellerCredential,
   verifyBuyerTeePaymentAttestation,
   verifyBuyerTeePayment,
+  verifyDispute,
+  verifyDisputeAttestation,
   verifyIdentityAttestation,
   verifySellerCredentialBundle,
 } from "@zkp2p/zkp2p-attestation";

package/dist/cli/verify.js

@@ -4510,10 +4510,8 @@ var DEFAULT_TIMEOUT_MS = 1e4;
 // src/trust/pins.ts
 var STAGING_PCR8 = "5636e3bd96f847cf12cfd9de7faa8cad0e6fa00962ce16ba185f8e5ea57105abb3cc9cc34f1e1e4de3444ceabcca7485";
 var PRODUCTION_PCR8 = "41a4ae0b9b96752cab5addb7d22689b3070e564e29f90a54316fa33fa38ea51387a6e887ea4f5a4b0cc34f69cea3f40e";
-var PREPROD_PCR8 = "5453c5bfb7d040285be5ba9af142f4fbdd9685d082f244b66c62bf7b22d8d02a638fa2e02b9a6fe8877953a9429209e0";
 var DEFAULT_EXPECTED_PCR8_BY_HOST = {
   "attestation-service-staging.zkp2p.xyz": normalizePcr8Pin(STAGING_PCR8, "bundled staging PCR8"),
-  "attestation-service-preprod.zkp2p.xyz": normalizePcr8Pin(PREPROD_PCR8, "bundled preprod PCR8"),
   "attestation-service.zkp2p.xyz": normalizePcr8Pin(PRODUCTION_PCR8, "bundled production PCR8")
 };