@integraledger/lcp-binding-evm-escrow 0.10.1 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,62 @@
 # @integraledger/lcp-binding-evm-escrow
 
+## 0.12.0
+
+### Patch Changes
+
+- @integraledger/lcp-binding-core@0.12.0
+- @integraledger/lcp-binding-evm-common@0.12.0
+
+## 0.10.2
+
+### Patch Changes
+
+- b2ffecc: Report the class a record actually supports, place a terms URL on UCP, and stop refusing a conformant UCP
+  profile — the remediation of the 2026-08-19 conformance re-audit.
+
+  **`verify` now computes `supportedClass` instead of echoing the claim.** It was `anyFailed ? "TC-0" :
+claimedClass`, so a record proving nothing — no settlement, no acceptance, no authority chain — reported
+  whatever class the caller named, while the field's own published docblock promised "what the record
+  honestly supports, not what the caller asked for". It is now the highest class every one of whose required
+  steps is `proved`, `TC-0` on any failure, computed from the steps alone: neither capped by the claim (rungs
+  that reach TC-3 read TC-3 where the caller claimed TC-2) nor lifted by it. White paper #4 §5 defines the
+  class of a transaction as "the highest class whose criteria it fully meets", and this is that.
+
+  The claim is not discarded — the report gains **`claimedClass`**, a required member, because `verified`
+  answers "did the record reach the class it claimed?" and cannot be read without it. The two fields are the
+  report's two halves: an input echoed, and a finding computed. Where they differ, the record did not reach
+  its own shape. An out-of-taxonomy claim now lands only in the echo and can no longer masquerade as a
+  finding.
+
+  **UCP can advertise a terms URL.** Its policy object declares `url` — "Optional link to the full policy
+  document", `format: uri` — on the very entry this placement writes, and §C.3's illustration carries `url`
+  and `atrHash` side by side there. The manifest previously said the protocol had no slot, citing `links[]`,
+  which §C.3 separates as "a standing page, not a per-transaction record". The obstacle was mechanical:
+  `termsUrlFields` addresses document paths, and a tagged-array entry's index is chosen at write time. The
+  `tagged-array` container therefore gains `termsUrlField`, written onto the same entry in the same write, and
+  read back through the same first-match rule. UCP was the last shipped protocol that refused an
+  advertisement carrying its own locator (integra-protocol#8).
+
+  **`readUcpProfile` no longer refuses a conformant business profile.** `requireHttps` mapped an ABSENT `spec`
+  to the same branch as a malformed one, and the live host requires `spec` only of a platform declaration —
+  as this repository's own README already said. It is now `requireHttpsIfDeclared`: absence is absence, and a
+  declared value is still held to the host's https MUST.
+
+  Also: `requireWritten` replaces an unchecked cast in the x402 override, so a broken postcondition throws
+  instead of returning a success carrying no document; six x402 citations move to the revision that actually
+  touches the file they name, and a new gate refuses any `owner/repo@sha` in source that `spec-pins.json` does
+  not record; four spec citations move from line anchors to section anchors; the escrow binding states why it
+  declares no §8.3.1 off-canonical variant, and asserts it; and §C.3's `policies[]` illustration is recorded as
+  invalid against the live UCP schema, which shows `description` as a bare string where the host requires an
+  object — owed upstream, not a defect here.
+
+  Corpus 844 → 847, root `ec4ad1b02a81538b…`.
+
+- Updated dependencies [b2ffecc]
+- Updated dependencies [822190a]
+  - @integraledger/lcp-binding-core@0.11.0
+  - @integraledger/lcp-binding-evm-common@0.10.2
+
 ## 0.10.1
 
 **0.10.0 was staged and withdrawn before approval; this is that release, re-cut.** The conformance corpus

package/README.md

@@ -48,6 +48,14 @@ atrHashFromSalt(0n); // the inverse, for a salt you already hold
 The ATR hash rides `PaymentInfo.salt` — an existing field the service already controls. No derivation,
 no overlay contract.
 
+**The ATR hash must be per-transaction.** `salt` is the struct's entropy source — *"a source of entropy to
+ensure unique hashes across different payments"* — and an ATR hash carries none: it is deterministic and
+identical for every payment made under one terms document. The escrow keys its state on the hash of the
+whole `PaymentInfo` and refuses one it has already collected, so a repeat purchase under the same ATR with
+the same payer, caps and expiries reverts on chain with `PaymentAlreadyCollected`. Nothing in this package
+can detect that — the collision is between two transactions it never sees together. Mint a fresh ATR per
+transaction, which LCP §6.1 wants anyway.
+
 ```ts
 import { EVENT_TO_STATE } from "@integraledger/lcp-binding-evm-escrow";
 

package/dist/manifest.d.ts

@@ -8,6 +8,16 @@ import type { BindingManifest } from "@integraledger/lcp-binding-core";
  * in `PaymentAuthorized`/`PaymentCharged` event data, so `recover`/`enumerate` decode the event and read
  * `salt` (proven on-chain).
  *
+ * **NO `offCanonical`, and that silence is examined rather than default.** §8.3.1 admits the marker only
+ * where the field is "specified as client-chosen or as a deterministic derivation that excludes
+ * `atrHash`", and `salt` meets NEITHER disjunct: `charge`/`authorize` are
+ * `onlySender(paymentInfo.operator)`, so the SERVICE constructs the whole struct and the payer signs only
+ * a hash of it, and the welded value IS `uint256(atrHash)` — a derivation that includes it. Nothing
+ * on-chain constrains the field's value, which is §8.3.1's Tier A condition. The x402 sibling declares
+ * `offCanonical` over the EIP-3009 nonce because THAT field is payer-chosen and its weld therefore needs
+ * a cooperating client stack; this one needs none, so mirroring the sibling would publish a
+ * controlled-client caveat that does not apply here.
+ *
  * **recovery.forwardIndexable = false** — the criterion is enumeration bound to a GIVEN atrHash, and this
  * rail cannot do it. `paymentInfoHash` is the only indexed topic, and it is a hash of the whole
  * `PaymentInfo` struct: a caller holding the complete struct could topic-filter, but a caller holding only

package/dist/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,eAAe,EAAE,eA+B7B,CAAC"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,eAAe,EAAE,eA+B7B,CAAC"}

package/dist/manifest.js

@@ -7,6 +7,16 @@
  * in `PaymentAuthorized`/`PaymentCharged` event data, so `recover`/`enumerate` decode the event and read
  * `salt` (proven on-chain).
  *
+ * **NO `offCanonical`, and that silence is examined rather than default.** §8.3.1 admits the marker only
+ * where the field is "specified as client-chosen or as a deterministic derivation that excludes
+ * `atrHash`", and `salt` meets NEITHER disjunct: `charge`/`authorize` are
+ * `onlySender(paymentInfo.operator)`, so the SERVICE constructs the whole struct and the payer signs only
+ * a hash of it, and the welded value IS `uint256(atrHash)` — a derivation that includes it. Nothing
+ * on-chain constrains the field's value, which is §8.3.1's Tier A condition. The x402 sibling declares
+ * `offCanonical` over the EIP-3009 nonce because THAT field is payer-chosen and its weld therefore needs
+ * a cooperating client stack; this one needs none, so mirroring the sibling would publish a
+ * controlled-client caveat that does not apply here.
+ *
  * **recovery.forwardIndexable = false** — the criterion is enumeration bound to a GIVEN atrHash, and this
  * rail cannot do it. `paymentInfoHash` is the only indexed topic, and it is a hash of the whole
  * `PaymentInfo` struct: a caller holding the complete struct could topic-filter, but a caller holding only
@@ -61,7 +71,7 @@ export const ESCROW_MANIFEST = {
     indexing: "event-data-scan:paymentInfoHash",
     finality: {
         reversible: true,
-        note: 'on-rail void/refund within refundExpiry — not dispute resolution (RCS-5); capture is not reversed, refund is a fresh on-rail remedy The atrHash welded into PaymentInfo.salt MUST be per-transaction: salt is specified as the struct\'s entropy source ("a source of entropy to ensure unique hashes across different payments") and an atrHash carries none, so a repeat purchase under one ATR with the same payer, caps and expiries produces a PaymentInfo the escrow has already seen and reverts.',
+        note: 'on-rail void/refund within refundExpiry — not dispute resolution (RCS-5); capture is not reversed, refund is a fresh on-rail remedy. The atrHash welded into PaymentInfo.salt MUST be per-transaction: salt is specified as the struct\'s entropy source ("a source of entropy to ensure unique hashes across different payments") and an atrHash carries none, so a repeat purchase under one ATR with the same payer, caps and expiries produces a PaymentInfo the escrow has already seen and reverts.',
     },
     weldGrades: {
         ERC3009: "signature",

package/dist/manifest.js.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,CAAC,MAAM,eAAe,GAAoB;IAC9C,IAAI,EAAE,YAAY;IAClB,OAAO,EAAE,cAAc;IACvB,WAAW,EAAE,kBAAkB;IAC/B,QAAQ,EAAE;QACR,OAAO,EAAE,IAAI;QACb,oBAAoB,EAAE,IAAI;QAC1B,gBAAgB,EAAE,KAAK;KACxB;IACD,YAAY,EAAE,SAAS,EAAE,uFAAuF;IAChH,WAAW,EAAE,YAAY,EAAE,qEAAqE;IAChG,QAAQ,EAAE,iCAAiC;IAC3C,QAAQ,EAAE;QACR,UAAU,EAAE,IAAI;QAChB,IAAI,EAAE,0eAA0e;KACjf;IACD,UAAU,EAAE;QACV,OAAO,EAAE,WAAW;QACpB,OAAO,EAAE,WAAW;QACpB,eAAe,EAAE,WAAW;QAC5B,WAAW,EAAE,IAAI;KAClB;IACD,eAAe,EAAE;QACf,UAAU;QACV,YAAY;QACZ,UAAU;QACV,SAAS;QACT,QAAQ;QACR,WAAW;QACX,UAAU;KACX;CACF,CAAC"}
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,MAAM,CAAC,MAAM,eAAe,GAAoB;IAC9C,IAAI,EAAE,YAAY;IAClB,OAAO,EAAE,cAAc;IACvB,WAAW,EAAE,kBAAkB;IAC/B,QAAQ,EAAE;QACR,OAAO,EAAE,IAAI;QACb,oBAAoB,EAAE,IAAI;QAC1B,gBAAgB,EAAE,KAAK;KACxB;IACD,YAAY,EAAE,SAAS,EAAE,uFAAuF;IAChH,WAAW,EAAE,YAAY,EAAE,qEAAqE;IAChG,QAAQ,EAAE,iCAAiC;IAC3C,QAAQ,EAAE;QACR,UAAU,EAAE,IAAI;QAChB,IAAI,EAAE,2eAA2e;KAClf;IACD,UAAU,EAAE;QACV,OAAO,EAAE,WAAW;QACpB,OAAO,EAAE,WAAW;QACpB,eAAe,EAAE,WAAW;QAC5B,WAAW,EAAE,IAAI;KAClB;IACD,eAAe,EAAE;QACf,UAAU;QACV,YAAY;QACZ,UAAU;QACV,SAAS;QACT,QAAQ;QACR,WAAW;QACX,UAAU;KACX;CACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@integraledger/lcp-binding-evm-escrow",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "Welds an ATR hash into an authorize-and-capture escrow settlement on EVM chains.",
   "keywords": [
     "lcp",
@@ -43,13 +43,13 @@
   "homepage": "https://github.com/IntegraLedger/integra-protocol/tree/main/packages/binding-evm-escrow#readme",
   "dependencies": {
     "viem": "2.55.11",
-    "@integraledger/lcp-binding-evm-common": "0.10.1",
-    "@integraledger/lcp-binding-core": "0.10.1"
+    "@integraledger/lcp-binding-core": "0.12.0",
+    "@integraledger/lcp-binding-evm-common": "0.12.0"
   },
   "devDependencies": {
     "@types/node": "24.13.3",
     "vitest": "4.1.10",
-    "@integraledger/lcp-kernel": "0.10.1"
+    "@integraledger/lcp-kernel": "0.12.0"
   },
   "license": "Apache-2.0",
   "engines": {

package/src/manifest.ts

@@ -9,6 +9,16 @@ import type { BindingManifest } from "@integraledger/lcp-binding-core";
  * in `PaymentAuthorized`/`PaymentCharged` event data, so `recover`/`enumerate` decode the event and read
  * `salt` (proven on-chain).
  *
+ * **NO `offCanonical`, and that silence is examined rather than default.** §8.3.1 admits the marker only
+ * where the field is "specified as client-chosen or as a deterministic derivation that excludes
+ * `atrHash`", and `salt` meets NEITHER disjunct: `charge`/`authorize` are
+ * `onlySender(paymentInfo.operator)`, so the SERVICE constructs the whole struct and the payer signs only
+ * a hash of it, and the welded value IS `uint256(atrHash)` — a derivation that includes it. Nothing
+ * on-chain constrains the field's value, which is §8.3.1's Tier A condition. The x402 sibling declares
+ * `offCanonical` over the EIP-3009 nonce because THAT field is payer-chosen and its weld therefore needs
+ * a cooperating client stack; this one needs none, so mirroring the sibling would publish a
+ * controlled-client caveat that does not apply here.
+ *
  * **recovery.forwardIndexable = false** — the criterion is enumeration bound to a GIVEN atrHash, and this
  * rail cannot do it. `paymentInfoHash` is the only indexed topic, and it is a hash of the whole
  * `PaymentInfo` struct: a caller holding the complete struct could topic-filter, but a caller holding only
@@ -63,7 +73,7 @@ export const ESCROW_MANIFEST: BindingManifest = {
   indexing: "event-data-scan:paymentInfoHash",
   finality: {
     reversible: true,
-    note: 'on-rail void/refund within refundExpiry — not dispute resolution (RCS-5); capture is not reversed, refund is a fresh on-rail remedy The atrHash welded into PaymentInfo.salt MUST be per-transaction: salt is specified as the struct\'s entropy source ("a source of entropy to ensure unique hashes across different payments") and an atrHash carries none, so a repeat purchase under one ATR with the same payer, caps and expiries produces a PaymentInfo the escrow has already seen and reverts.',
+    note: 'on-rail void/refund within refundExpiry — not dispute resolution (RCS-5); capture is not reversed, refund is a fresh on-rail remedy. The atrHash welded into PaymentInfo.salt MUST be per-transaction: salt is specified as the struct\'s entropy source ("a source of entropy to ensure unique hashes across different payments") and an atrHash carries none, so a repeat purchase under one ATR with the same payer, caps and expiries produces a PaymentInfo the escrow has already seen and reverts.',
   },
   weldGrades: {
     ERC3009: "signature",