@agentcontextdistributionprotocol/acdp-wasm 0.8.4 → 0.14.0

package/README.md

@@ -42,8 +42,9 @@ wasm-bindgen exports (camelCase in JS/TypeScript):
 |---|---|---|
 | `verifyContentHash` | 0001 §5.7 | recompute `sha256(JCS(producer_content))` |
 | `verifySignatureEd25519` / `verifySignatureP256` | 0001 §5.8 | signature over the ASCII `"sha256:<hex>"` string |
+| `verifyCtxIdBinding` | 0006 §4.1 step 7 | bind the served `ctx_id` to the one requested — see [Verifying a retrieved body](#verifying-a-retrieved-body) |
 | `verifyBodyOffline` / `verifyPublishRequestOffline` | 0002 | full `did:key` context verify (no resolution) |
-| `fingerprintEd25519` / `verifyReceipt` | 0010 | registry-receipt verification |
+| `fingerprintEd25519` / `verifyReceipt(receiptJson, bodyJson, registryPublicKeyB64, expectedCtxId, recomputedBodyHash, producerKeyFingerprint)` | 0010 | registry-receipt verification — see [Verifying a registry receipt](#verifying-a-registry-receipt) below |
 | `verifyLineageHeadReceipt` | 0011 | lineage-head receipt |
 | `verifyLogCheckpoint` / `verifyLogInclusion` / `verifyLogConsistency` / `buildLogLeaf` / `merkleLeafHash` / `merkleNodeHash` / `merkleRootHash` | 0012 | transparency log |
 | `verifyLifecycleEvent` | 0013 | lifecycle event |
@@ -63,13 +64,53 @@ npm install @agentcontextdistributionprotocol/acdp-wasm
 ```
 
 ```js
-import init, { verifyContentHash, verifySignatureEd25519 }
+import init, { verifyContentHash, verifySignatureEd25519, verifyCtxIdBinding }
   from "@agentcontextdistributionprotocol/acdp-wasm";
 await init();
 const verdict = JSON.parse(verifyContentHash(bodyJson, body.content_hash));
 if (verdict.valid) { /* the hash the consumer recomputed itself checks out */ }
+
+// Bind the served ctx_id to the one requested (RFC-ACDP-0006 §4.1 step 7).
+// See "Verifying a retrieved body" below for why this is a separate call.
+const binding = JSON.parse(verifyCtxIdBinding(bodyJson, requestedCtxId));
+if (binding.valid) { /* the ctx_id you got back is the one you asked for */ }
 ```
 
+### Verifying a retrieved body
+
+`ctx_id` is registry-assigned and sits in the RFC-ACDP-0001 §5.7 exclusion
+set, so it is stripped before `content_hash` is computed — neither the hash
+recompute above nor the producer's signature covers it. Without an
+explicit comparison, a registry could serve any other validly-signed body
+from the same producer under the `ctx_id` URL you asked for, and every
+check above would still pass. `verifyCtxIdBinding(bodyJson, expectedCtxId)`
+closes that gap: `bodyJson` carries the *served* identity, `expectedCtxId`
+is what you requested. Like `verifyContentHash`, a malformed *served*
+`ctx_id` is a `{"valid": false, ...}` verdict, not a throw — only a
+malformed `expectedCtxId` argument throws a `JsError`.
+
+### Verifying a registry receipt
+
+`verifyReceipt` (RFC-ACDP-0010 §8) takes the accompanying `bodyJson` as a
+**required** second argument — it binds the receipt's `lineage_id`,
+`origin_registry`, and `created_at` to the served body's own fields (§8
+step 3):
+
+```js
+const verdict = JSON.parse(verifyReceipt(
+  receiptJson, bodyJson, registryPublicKeyB64,
+  expectedCtxId, recomputedBodyHash, producerKeyFingerprint,
+));
+```
+
+A malformed `bodyJson` throws a `JsError` (host input); a body/receipt
+mismatch is a `{"valid": false, ...}` verdict (verification outcome), not
+a throw — same convention as `verifyContentHash` / `verifyCtxIdBinding`.
+Two checks still stay the HOST's obligation, because neither needs the
+body: the serving-authority binding (`receipt.registry_did` must equal
+the authority you actually fetched from) and recomputing (never
+trusting) the body hash you pass in.
+
 The package is built with `wasm-pack --target web`: an ESM module you
 initialize once with `await init()`. This is the target the crate is
 designed and CI-tested around, and it loads cleanly in browsers and in
@@ -94,10 +135,12 @@ wasm-pack build --target web --out-dir pkg --scope agentcontextdistributionproto
 Import from a browser (local, unpublished build):
 
 ```js
-import init, { verifyContentHash, verifySignatureEd25519 } from "./pkg/acdp_wasm.js";
+import init, { verifyContentHash, verifySignatureEd25519, verifyCtxIdBinding } from "./pkg/acdp_wasm.js";
 await init();
 const verdict = JSON.parse(verifyContentHash(bodyJson, body.content_hash));
 if (verdict.valid) { /* the hash the consumer recomputed itself checks out */ }
+const binding = JSON.parse(verifyCtxIdBinding(bodyJson, requestedCtxId));
+if (binding.valid) { /* the ctx_id you got back is the one you asked for */ }
 ```
 
 ## Golden-vector parity

package/acdp_wasm.d.ts

@@ -73,6 +73,18 @@ export function verifyBodyOffline(body_json: string): string;
  */
 export function verifyContentHash(body_json: string, expected_hash: string): string;
 
+/**
+ * Verify that a body's *served* `ctx_id` matches the `ctx_id` the
+ * caller *expected* (RFC-ACDP-0006 §4.1 step 7, NORMATIVE). Argument
+ * order is `(bodyJson, expectedCtxId)`: the body's own `ctx_id` is the
+ * *served* identity, `expectedCtxId` is what the caller requested.
+ * Returns a verdict for the served side (a malformed served `ctx_id`,
+ * or a served/expected mismatch, is a fail verdict). Throws on
+ * malformed body JSON or a malformed `expectedCtxId` — that value is
+ * host input, mirroring `verifyContentHash`'s `expectedHash`.
+ */
+export function verifyCtxIdBinding(body_json: string, expected_ctx_id: string): string;
+
 /**
  * Verify one lifecycle event offline (RFC-ACDP-0013 §5).
  * `actorDidDocJson` is `null`/`undefined` for a `did:key` actor.
@@ -110,10 +122,11 @@ export function verifyPublishRequestOffline(request_json: string): string;
 
 /**
  * Verify a registry receipt (RFC-ACDP-0010) against the consumer's own
- * recomputed body hash / expected ctx_id / producer key fingerprint.
- * Returns a verdict.
+ * recomputed body hash / expected ctx_id / producer key fingerprint,
+ * and bind it to the accompanying `body_json` (§8 step 3). Returns a
+ * verdict.
  */
-export function verifyReceipt(receipt_json: string, registry_public_key_b64: string, expected_ctx_id: string, recomputed_body_hash: string, producer_key_fingerprint: string): string;
+export function verifyReceipt(receipt_json: string, body_json: string, registry_public_key_b64: string, expected_ctx_id: string, recomputed_body_hash: string, producer_key_fingerprint: string): string;
 
 /**
  * Verify an Ed25519 signature over the ASCII `"sha256:<hex>"` string.
@@ -152,13 +165,14 @@ export interface InitOutput {
     readonly resolveDidKey: (a: number, b: number, c: number) => void;
     readonly verifyBodyOffline: (a: number, b: number, c: number) => void;
     readonly verifyContentHash: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly verifyCtxIdBinding: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly verifyLifecycleEvent: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly verifyLineageHeadReceipt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: bigint, l: number, m: bigint) => void;
     readonly verifyLogCheckpoint: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: bigint) => void;
     readonly verifyLogConsistency: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly verifyLogInclusion: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly verifyPublishRequestOffline: (a: number, b: number, c: number) => void;
-    readonly verifyReceipt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+    readonly verifyReceipt: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => void;
     readonly verifySignatureEd25519: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly verifySignatureP256: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly verifyWitnessCosignature: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: bigint) => void;

package/acdp_wasm.js

@@ -492,6 +492,48 @@ export function verifyContentHash(body_json, expected_hash) {
     }
 }
 
+/**
+ * Verify that a body's *served* `ctx_id` matches the `ctx_id` the
+ * caller *expected* (RFC-ACDP-0006 §4.1 step 7, NORMATIVE). Argument
+ * order is `(bodyJson, expectedCtxId)`: the body's own `ctx_id` is the
+ * *served* identity, `expectedCtxId` is what the caller requested.
+ * Returns a verdict for the served side (a malformed served `ctx_id`,
+ * or a served/expected mismatch, is a fail verdict). Throws on
+ * malformed body JSON or a malformed `expectedCtxId` — that value is
+ * host input, mirroring `verifyContentHash`'s `expectedHash`.
+ * @param {string} body_json
+ * @param {string} expected_ctx_id
+ * @returns {string}
+ */
+export function verifyCtxIdBinding(body_json, expected_ctx_id) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(body_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(expected_ctx_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.verifyCtxIdBinding(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export3(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * Verify one lifecycle event offline (RFC-ACDP-0013 §5).
  * `actorDidDocJson` is `null`/`undefined` for a `did:key` actor.
@@ -730,47 +772,51 @@ export function verifyPublishRequestOffline(request_json) {
 
 /**
  * Verify a registry receipt (RFC-ACDP-0010) against the consumer's own
- * recomputed body hash / expected ctx_id / producer key fingerprint.
- * Returns a verdict.
+ * recomputed body hash / expected ctx_id / producer key fingerprint,
+ * and bind it to the accompanying `body_json` (§8 step 3). Returns a
+ * verdict.
  * @param {string} receipt_json
+ * @param {string} body_json
  * @param {string} registry_public_key_b64
  * @param {string} expected_ctx_id
  * @param {string} recomputed_body_hash
  * @param {string} producer_key_fingerprint
  * @returns {string}
  */
-export function verifyReceipt(receipt_json, registry_public_key_b64, expected_ctx_id, recomputed_body_hash, producer_key_fingerprint) {
-    let deferred7_0;
-    let deferred7_1;
+export function verifyReceipt(receipt_json, body_json, registry_public_key_b64, expected_ctx_id, recomputed_body_hash, producer_key_fingerprint) {
+    let deferred8_0;
+    let deferred8_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(receipt_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(registry_public_key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr1 = passStringToWasm0(body_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(expected_ctx_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr2 = passStringToWasm0(registry_public_key_b64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len2 = WASM_VECTOR_LEN;
-        const ptr3 = passStringToWasm0(recomputed_body_hash, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr3 = passStringToWasm0(expected_ctx_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len3 = WASM_VECTOR_LEN;
-        const ptr4 = passStringToWasm0(producer_key_fingerprint, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr4 = passStringToWasm0(recomputed_body_hash, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len4 = WASM_VECTOR_LEN;
-        wasm.verifyReceipt(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+        const ptr5 = passStringToWasm0(producer_key_fingerprint, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len5 = WASM_VECTOR_LEN;
+        wasm.verifyReceipt(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
         var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        var ptr6 = r0;
-        var len6 = r1;
+        var ptr7 = r0;
+        var len7 = r1;
         if (r3) {
-            ptr6 = 0; len6 = 0;
+            ptr7 = 0; len7 = 0;
             throw takeObject(r2);
         }
-        deferred7_0 = ptr6;
-        deferred7_1 = len6;
-        return getStringFromWasm0(ptr6, len6);
+        deferred8_0 = ptr7;
+        deferred8_1 = len7;
+        return getStringFromWasm0(ptr7, len7);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export3(deferred7_0, deferred7_1, 1);
+        wasm.__wbindgen_export3(deferred8_0, deferred8_1, 1);
     }
 }
 
@@ -898,18 +944,18 @@ export function verifyWitnessCosignature(cosig_json, witness_did_doc_json, expec
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_408e67f47ca7b58b: function(arg0, arg1) {
+        __wbg_Error_67e7344beaa85059: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         },
-        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
+        __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_getTime_63fb0332e6c4ec17: function(arg0) {
+        __wbg_getTime_65922ba0b59d55a7: function(arg0) {
             const ret = getObject(arg0).getTime();
             return ret;
         },
-        __wbg_new_0_f117d868b403dc07: function() {
+        __wbg_new_0_35540e542ba689d2: function() {
             const ret = new Date();
             return addHeapObject(ret);
         },

package/package.json

@@ -2,7 +2,7 @@
   "name": "@agentcontextdistributionprotocol/acdp-wasm",
   "type": "module",
   "description": "Agent Context Distribution Protocol — WebAssembly verification core",
-  "version": "0.8.4",
+  "version": "0.14.0",
   "license": "MIT OR Apache-2.0",
   "files": [
     "acdp_wasm_bg.wasm",