@coffre/core 0.1.12 → 0.1.13

package/dist/vault.d.ts

@@ -67,6 +67,12 @@ export declare function describeAccessFault(fault: AccessFault, names?: FaultNam
 export declare function checkpointMessage(checkpoint: Omit<Checkpoint, 'signature' | 'keyId'>): Uint8Array<ArrayBuffer>;
 /** Whether `checkpoint` was signed by the key whose raw public half is `publicKey`. */
 export declare function verifyCheckpoint(checkpoint: Checkpoint, publicKey: string): Promise<boolean>;
+/**
+ * `verifyCheckpoint` for many checkpoints signed by one key, the key
+ * imported once: a full verification checks every checkpoint, one every
+ * five minutes.
+ */
+export declare function checkpointVerifier(publicKey: string): Promise<(checkpoint: Checkpoint) => Promise<boolean>>;
 //#endregion
 //#region src/vault.d.ts
 /**
@@ -162,11 +168,13 @@ export interface Vault {
    */
   keyChecks(): Promise<KeyChecks>;
   /**
-   * Check the whole log: rehash it from the first entry, the vault's
-   * entries by their MACs, every checkpoint against the prefix it signed,
+   * Check the whole log: the vault's entries by their MACs, every
+   * checkpoint against the prefix it signed, the key batches accounted for,
    * and replay it to see that who is a member, and what they hold, follow
-   * from it. A verdict and nothing else, so anyone may ask; the app asks
-   * for owners.
+   * from it. The links and hashes of the chain are the caller's to
+   * recompute through `upTo`, as the app does first; with none, the vault
+   * recomputes them all itself. A verdict and nothing else, so anyone may
+   * ask; the app asks for owners.
    */
   verifyLog(input: VerifyLogInput): Promise<LogVerification>;
 }
@@ -372,9 +380,11 @@ export type LogHead = {
 };
 export type VerifyLogInput = {
   /**
-   * The last entry the app verified, its own entries by its key: the vault
-   * checks the log still holds it, so between them both authors' entries
-   * are authenticated over the same prefix.
+   * The last entry the app verified, every link and hash up to it
+   * recomputed and its own entries checked by its key: the vault checks the
+   * log still holds it, so between them both authors' entries are
+   * authenticated over the same prefix, and the vault leaves the links to
+   * the app.
    */
   upTo?: LogHead | null;
 };

package/dist/vault.js

@@ -6,8 +6,16 @@ function checkpointMessage(checkpoint) {
 }
 /** Whether `checkpoint` was signed by the key whose raw public half is `publicKey`. */
 async function verifyCheckpoint(checkpoint, publicKey) {
+	return (await checkpointVerifier(publicKey))(checkpoint);
+}
+/**
+* `verifyCheckpoint` for many checkpoints signed by one key, the key
+* imported once: a full verification checks every checkpoint, one every
+* five minutes.
+*/
+async function checkpointVerifier(publicKey) {
 	const key = await crypto.subtle.importKey("raw", new Uint8Array(Buffer.from(publicKey, "base64")), { name: "Ed25519" }, false, ["verify"]);
-	return crypto.subtle.verify("Ed25519", key, new Uint8Array(Buffer.from(checkpoint.signature, "base64")), checkpointMessage(checkpoint));
+	return (checkpoint) => crypto.subtle.verify("Ed25519", key, new Uint8Array(Buffer.from(checkpoint.signature, "base64")), checkpointMessage(checkpoint));
 }
 //#endregion
 //#region src/access-fault.ts
@@ -42,4 +50,4 @@ const ACCESS_ACTIONS = [
 	"access.revoke"
 ];
 //#endregion
-export { ACCESS_ACTIONS, checkpointMessage, describeAccessFault, verifyCheckpoint };
+export { ACCESS_ACTIONS, checkpointMessage, checkpointVerifier, describeAccessFault, verifyCheckpoint };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffre/core",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "What coffre's packages share: roles, envelopes, identity, the audit chain and the vault's contract.",
   "license": "MIT",
   "repository": {
@@ -69,7 +69,7 @@
     "@types/node": "26.1.1",
     "tsdown": "0.23.0",
     "typescript": "5.9.3",
-    "@coffre/conformance": "0.1.12"
+    "@coffre/conformance": "0.1.13"
   },
   "scripts": {
     "build": "tsdown",

package/src/checkpoint.ts

@@ -8,6 +8,15 @@ export function checkpointMessage(checkpoint: Omit<Checkpoint, 'signature' | 'ke
 
 /** Whether `checkpoint` was signed by the key whose raw public half is `publicKey`. */
 export async function verifyCheckpoint(checkpoint: Checkpoint, publicKey: string): Promise<boolean> {
+  return (await checkpointVerifier(publicKey))(checkpoint);
+}
+
+/**
+ * `verifyCheckpoint` for many checkpoints signed by one key, the key
+ * imported once: a full verification checks every checkpoint, one every
+ * five minutes.
+ */
+export async function checkpointVerifier(publicKey: string): Promise<(checkpoint: Checkpoint) => Promise<boolean>> {
   const key = await crypto.subtle.importKey('raw', new Uint8Array(Buffer.from(publicKey, 'base64')), { name: 'Ed25519' }, false, ['verify']);
-  return crypto.subtle.verify('Ed25519', key, new Uint8Array(Buffer.from(checkpoint.signature, 'base64')), checkpointMessage(checkpoint));
+  return (checkpoint) => crypto.subtle.verify('Ed25519', key, new Uint8Array(Buffer.from(checkpoint.signature, 'base64')), checkpointMessage(checkpoint));
 }

package/src/vault.ts

@@ -1,7 +1,7 @@
 import type { AccessFault } from './access-fault.ts';
 import type { Role } from './access.ts';
 
-export { checkpointMessage, verifyCheckpoint } from './checkpoint.ts';
+export { checkpointMessage, checkpointVerifier, verifyCheckpoint } from './checkpoint.ts';
 export { describeAccessFault, type AccessFault, type FaultGrant, type FaultNames } from './access-fault.ts';
 
 /**
@@ -77,11 +77,13 @@ export interface Vault {
    */
   keyChecks(): Promise<KeyChecks>;
   /**
-   * Check the whole log: rehash it from the first entry, the vault's
-   * entries by their MACs, every checkpoint against the prefix it signed,
+   * Check the whole log: the vault's entries by their MACs, every
+   * checkpoint against the prefix it signed, the key batches accounted for,
    * and replay it to see that who is a member, and what they hold, follow
-   * from it. A verdict and nothing else, so anyone may ask; the app asks
-   * for owners.
+   * from it. The links and hashes of the chain are the caller's to
+   * recompute through `upTo`, as the app does first; with none, the vault
+   * recomputes them all itself. A verdict and nothing else, so anyone may
+   * ask; the app asks for owners.
    */
   verifyLog(input: VerifyLogInput): Promise<LogVerification>;
 }
@@ -276,9 +278,11 @@ export type LogHead = { seq: number; hash: string };
 
 export type VerifyLogInput = {
   /**
-   * The last entry the app verified, its own entries by its key: the vault
-   * checks the log still holds it, so between them both authors' entries
-   * are authenticated over the same prefix.
+   * The last entry the app verified, every link and hash up to it
+   * recomputed and its own entries checked by its key: the vault checks the
+   * log still holds it, so between them both authors' entries are
+   * authenticated over the same prefix, and the vault leaves the links to
+   * the app.
    */
   upTo?: LogHead | null;
 };