cesr-ts 0.4.0 → 0.6.0

package/esm/src/primitives/verfer.js

@@ -1,26 +1,70 @@
+import { ed25519 } from "@noble/curves/ed25519";
+import { p256 } from "@noble/curves/nist";
+import { secp256k1 } from "@noble/curves/secp256k1";
 import { UnknownCodeError } from "../core/errors.js";
-import { matterCodexName, VERFER_CODES } from "./codex.js";
+import { matterCodexName, MtrDex, VERFER_CODES } from "./codex.js";
 import { Matter, parseMatter } from "./matter.js";
 /**
  * Verification-key primitive.
  *
  * KERIpy substance: `Verfer` wraps public verification key material and
  * constrains accepted derivation codes to verifier key families.
+ *
+ * Responsibility split:
+ * - `Matter` owns derivation-code semantics such as transferability
+ * - `Verfer` owns suite-dispatched signature verification
  */
 export class Verfer extends Matter {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
-        if (!VERFER_CODES.has(this.code)) {
-            throw new UnknownCodeError(`Expected verification key code, got ${this.code}`);
-        }
+        super(init);
+        Object.defineProperty(this, "_verifyRaw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Verfer.assertSupportedCode(this.code);
+        this._verifyRaw = Verfer.bindSuite(this.code, this.raw);
     }
+    /** Raw public verification key bytes used by suite-specific verify paths. */
     get key() {
         return this.raw;
     }
+    /** Human-oriented generated codex member name for diagnostics and tooling. */
     get algorithm() {
         return matterCodexName(this.code) ?? "UnknownKey";
     }
+    /** Verify one raw signature against one serialized message via this verifier's suite code. */
+    verify(sig, ser) {
+        return this._verifyRaw(sig, ser);
+    }
+    static assertSupportedCode(code) {
+        if (!VERFER_CODES.has(code)) {
+            throw new UnknownCodeError(`Expected verification key code, got ${code}`);
+        }
+    }
+    /** Bind one KERIpy-style verifier suite at construction time. */
+    static bindSuite(code, key) {
+        switch (code) {
+            case MtrDex.Ed25519:
+            case MtrDex.Ed25519N:
+                return (sig, ser) => ed25519.verify(sig, ser, key);
+            case MtrDex.ECDSA_256k1:
+            case MtrDex.ECDSA_256k1N:
+                return (sig, ser) => secp256k1.verify(sig, ser, key, {
+                    format: "compact",
+                    lowS: false,
+                    prehash: true,
+                });
+            case MtrDex.ECDSA_256r1:
+            case MtrDex.ECDSA_256r1N:
+                return (sig, ser) => p256.verify(sig, ser, key, {
+                    format: "compact",
+                    lowS: false,
+                    prehash: true,
+                });
+        }
+    }
 }
 /** Parse and hydrate `Verfer` from txt/qb2 bytes. */
 export function parseVerfer(input, cold) {

package/esm/src/primitives/verser.js

@@ -1,7 +1,7 @@
 import { b64ToInt } from "../core/bytes.js";
 import { DeserializeError, UnknownCodeError } from "../core/errors.js";
 import { VERSER_CODES, VERSER_PROTOCOLS } from "./codex.js";
-import { Matter, parseMatter } from "./matter.js";
+import { parseMatter } from "./matter.js";
 import { Tagger } from "./tagger.js";
 /** Decode 3-char CESR version token (`Mmm`) into major/minor version tuple. */
 function parseVersion(text) {
@@ -21,13 +21,13 @@ function parseVersion(text) {
  * Compact version primitive for protocol/genus version metadata.
  *
  * KERIpy semantics: payload tag is `proto + pvrsn (+ gvrsn optional)` where
- * proto is `KERI|ACDC`, `pvrsn` is always present, and `gvrsn` is present only
- * for 10-char tags.
+ * proto is usually `KERI|ACDC`, but KERIpy also permits auxiliary four-char
+ * tags such as `OCSR` used by typed-digest seal families. `pvrsn` is always
+ * present, and `gvrsn` is present only for 10-char tags.
  */
 export class Verser extends Tagger {
     constructor(init) {
-        const tagger = init instanceof Matter ? init : new Matter(init);
-        super(tagger);
+        super(init);
         if (!VERSER_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected verser code (Y/0O), got ${this.code}`);
         }
@@ -42,7 +42,17 @@ export class Verser extends Tagger {
         if (body.length === 10)
             parseVersion(body.slice(7, 10));
     }
-    /** Protocol namespace extracted from verser tag payload. */
+    /**
+     * Four-character verser namespace extracted from tag payload.
+     *
+     * Maintainer note:
+     * - native message bodies still only use the protocol literals from
+     *   `tables/versions.ts`
+     * - KERIpy also permits auxiliary four-char tags such as `OCSR` for
+     *   typed-digest seals, so this accessor may carry a value outside the
+     *   nominal protocol union even though the broader codebase still treats
+     *   top-level message bodies as `KERI|ACDC`
+     */
     get proto() {
         return this.tag.slice(0, 4);
     }

package/esm/src/router/router-stub.js

@@ -1,3 +1,4 @@
+/** Create a tiny protocol router without committing to a larger routing framework. */
 export function createRouterStub(handlers = {}) {
     return {
         async route(message) {