@coordination-network/revocation-registry 0.0.2 → 0.1.1

package/README.md

@@ -93,9 +93,9 @@ const rebuilt = RevocationRegistry.fromLeaves(slots)
 
 ### Snapshots
 
-Replaying every revocation since genesis gets slow. `export()` serializes the whole tree, hashes included, and `import()` rebuilds it without rehashing, so a service can publish periodic snapshots and a holder can sync from the latest one plus the few revocations after it.
+Replaying every revocation since genesis gets slow. `export()` serializes the whole tree, hashes included, and `import()` rebuilds it without recomputing every node, so a service can publish periodic snapshots and a holder can sync from the latest one plus the few revocations after it.
 
-`import()` validates by default that the serialized leaves and hashes agree with each other, which rejects a tampered snapshot. That is an internal-consistency check, not proof of authenticity: still compare `root` against the authority.
+`import()` validates by default: it rehashes the leaves against the serialized hashes and requires every leaf value to be a field element, which rejects a tampered snapshot. That is not proof of authenticity. Import a served snapshot with validation on, and compare `root` against the authority's.
 
 A snapshot carries the node hashes, so it is larger than the leaf slots and lets a publisher hand you hashes you did not derive. `fromLeaves` is the leaner and more suspicious option; `import` is the faster one when you produced the snapshot yourself.
 
@@ -141,7 +141,6 @@ An index is only valid against the tree state the write applies to. If another r
 ## Notes
 
 - Commitments must be non-zero and below the BN254 scalar field order. Zero is reserved for the sentinel leaf and for tombstones. Above the field order, two distinct values can reduce to the same field element, which would let one revocation silently cover an unrelated credential and would break the sorted ordering a non-membership proof relies on.
-- An empty registry cannot produce proofs. Nothing has been revoked, so a verifier should treat that as "no revocations", not as a failure.
 - Revocation is normally permanent. `unrevoke` exists because the structure supports it, but an un-revoked credential becomes valid again for every verifier still accepting an older root, and it leaves a tombstone that rules out rebuilding from `commitments` alone.
 - `indexOf` returns a physical slot, never a position in `commitments`. The two always differ by at least one, because slot 0 is the sentinel.
 - `revocationHashes` is the Poseidon pair every implementation of a registry must agree on: 3-input for leaves, 2-input for internal nodes. `tests/cross-language.test.ts` pins the resulting roots against the Solidity implementation.

package/dist/index.cjs

@@ -387,12 +387,20 @@ class RevocationRegistry {
      *
      * @param snapshot The serialized tree.
      * @param validate Recompute every commitment and check it against the
-     * serialized hashes, rejecting a tampered snapshot. Defaults to `true`; pass
-     * `false` only for data you produced yourself.
+     * serialized hashes and require every leaf value to be a field element,
+     * rejecting a tampered snapshot. Defaults to `true`; pass `false` only for
+     * data you produced yourself.
      */
     static import(snapshot, validate = true) {
         const tree = new RevocationRegistry();
         tree.leanIMTPlus = leanImtPlus.LeanIMTPlus.import(revocationHashes, snapshot, { validate });
+        // Hashing reduces mod p, so a leaf holding `c + p` matches the honest root while `isRevoked(c)` is false.
+        if (validate) {
+            for (const { value, nextValue } of tree.leafSlots) {
+                toFieldElement(value);
+                toFieldElement(nextValue);
+            }
+        }
         return tree;
     }
     /**

package/dist/index.js

@@ -385,12 +385,20 @@ class RevocationRegistry {
      *
      * @param snapshot The serialized tree.
      * @param validate Recompute every commitment and check it against the
-     * serialized hashes, rejecting a tampered snapshot. Defaults to `true`; pass
-     * `false` only for data you produced yourself.
+     * serialized hashes and require every leaf value to be a field element,
+     * rejecting a tampered snapshot. Defaults to `true`; pass `false` only for
+     * data you produced yourself.
      */
     static import(snapshot, validate = true) {
         const tree = new RevocationRegistry();
         tree.leanIMTPlus = LeanIMTPlus.import(revocationHashes, snapshot, { validate });
+        // Hashing reduces mod p, so a leaf holding `c + p` matches the honest root while `isRevoked(c)` is false.
+        if (validate) {
+            for (const { value, nextValue } of tree.leafSlots) {
+                toFieldElement(value);
+                toFieldElement(nextValue);
+            }
+        }
         return tree;
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coordination-network/revocation-registry",
-  "version": "0.0.2",
+  "version": "0.1.1",
   "description": "LeanIMT+ revocation registry in TypeScript: revoke credential commitments and generate membership and non-membership proofs, as the registry itself or as a mirror of one held elsewhere.",
   "license": "MIT",
   "repository": {

package/src/revocation-registry.ts

@@ -318,14 +318,23 @@ export class RevocationRegistry {
      *
      * @param snapshot The serialized tree.
      * @param validate Recompute every commitment and check it against the
-     * serialized hashes, rejecting a tampered snapshot. Defaults to `true`; pass
-     * `false` only for data you produced yourself.
+     * serialized hashes and require every leaf value to be a field element,
+     * rejecting a tampered snapshot. Defaults to `true`; pass `false` only for
+     * data you produced yourself.
      */
     public static import(snapshot: string, validate = true): RevocationRegistry {
         const tree = new RevocationRegistry()
 
         tree.leanIMTPlus = LeanIMTPlus.import(revocationHashes, snapshot, { validate })
 
+        // Hashing reduces mod p, so a leaf holding `c + p` matches the honest root while `isRevoked(c)` is false.
+        if (validate) {
+            for (const { value, nextValue } of tree.leafSlots) {
+                toFieldElement(value)
+                toFieldElement(nextValue)
+            }
+        }
+
         return tree
     }
 

package/types/index.d.ts

@@ -282,8 +282,9 @@ declare class RevocationRegistry {
      *
      * @param snapshot The serialized tree.
      * @param validate Recompute every commitment and check it against the
-     * serialized hashes, rejecting a tampered snapshot. Defaults to `true`; pass
-     * `false` only for data you produced yourself.
+     * serialized hashes and require every leaf value to be a field element,
+     * rejecting a tampered snapshot. Defaults to `true`; pass `false` only for
+     * data you produced yourself.
      */
     static import(snapshot: string, validate?: boolean): RevocationRegistry;
     /**