@smartledger/keys 3.0.0 → 3.1.1

package/dist/cjs/sdk.js

@@ -6,9 +6,29 @@
  * a clean, high-level API for key operations.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultKeySDK = void 0;
+exports.DefaultKeySDK = exports.agentIdOfKey = void 0;
 exports.createKeySDK = createKeySDK;
 const crypto_1 = require("@smartledger/crypto");
+Object.defineProperty(exports, "agentIdOfKey", { enumerable: true, get: function () { return crypto_1.agentIdOfKey; } });
+const COUNTER_SUFFIX = /^pk-[^:-]+-(\d+)$/;
+const MAX_KEY_ID_ATTEMPTS = 8;
+function assertAgentId(agentId) {
+    if (typeof agentId !== 'string' || agentId.length === 0) {
+        throw new Error('agentId must be a non-empty string');
+    }
+}
+function toRecord(meta, publicKey) {
+    // Copies, so a caller cannot reach registry state through a KeyRecord even
+    // when a custom storage backend hands out its own objects.
+    return { meta: (0, crypto_1.cloneKeyMeta)(meta), publicKey: Uint8Array.from(publicKey) };
+}
+function statusAllows(meta, policy) {
+    if (policy === 'any')
+        return true;
+    if (policy === 'not-revoked')
+        return meta.status !== 'revoked';
+    return (0, crypto_1.isKeyUsable)(meta);
+}
 /**
  * Default KeySDK implementation.
  *
@@ -19,6 +39,7 @@ class DefaultKeySDK {
         this.keyCounter = new Map(); // agentId -> counter
         this.counterInitialized = new Set();
         this.counterInitPromises = new Map();
+        this.getOrCreateInFlight = new Map();
         this.keyRegistry = config.keyRegistry;
         this.suiteRegistry = config.suiteRegistry;
     }
@@ -26,6 +47,7 @@ class DefaultKeySDK {
      * Create a new key for an agent.
      */
     async createKey(agentId, profile, options = {}) {
+        assertAgentId(agentId);
         // Get suite
         const suite = this.suiteRegistry.getSuite(profile.primarySignatureSuite);
         // Generate keypair (with optional derivation)
@@ -47,20 +69,16 @@ class DefaultKeySDK {
             // Standard random key generation
             keypair = await suite.generateKeypair();
         }
-        // Generate unique keyId
-        const counter = await this.getNextCounter(agentId);
-        const suiteName = profile.primarySignatureSuite.split('-')[0]; // 'ml-dsa' or 'bsv'
-        const keyId = `${agentId}:pk-${suiteName}-${counter}`;
-        // Register key
-        const meta = await this.keyRegistry.registerKey(keyId, keypair, profile.primarySignatureSuite, {
+        const meta = await this.registerUnderFreshId(agentId, profile.primarySignatureSuite, keyId => this.keyRegistry.registerKey(keyId, keypair, profile.primarySignatureSuite, {
             expiresAt: options.expiresAt,
             usage: options.usage || ['signing'],
             cryptoProfileVersion: options.cryptoProfileVersion || '1.0.0',
-        });
-        return {
-            meta,
-            publicKey: keypair.publicKey,
-        };
+            // Record that (and where) the key was derived. Never the seed.
+            derivation: options.derivationContext
+                ? { path: options.derivationContext.path ?? '' }
+                : undefined,
+        }));
+        return toRecord(meta, keypair.publicKey);
     }
     /**
      * Get an existing key.
@@ -70,13 +88,13 @@ class DefaultKeySDK {
         if (!result) {
             return null;
         }
-        return {
-            meta: result.meta,
-            publicKey: result.publicKey,
-        };
+        return toRecord(result.meta, result.publicKey);
     }
     /**
      * Sign with a key (private key never exposed).
+     *
+     * @throws if the key is unknown, not active, past its `expiresAt`, or not
+     *   registered for signing
      */
     async signWithKey(keyId, message) {
         // Get full keypair (private access)
@@ -84,9 +102,15 @@ class DefaultKeySDK {
         if (!result) {
             throw new Error(`Key not found: ${keyId}`);
         }
-        if (result.meta.status !== 'active') {
+        if (result.meta.status && result.meta.status !== 'active') {
             throw new Error(`Key is not active: ${keyId} (status: ${result.meta.status})`);
         }
+        // Status alone is not enough: an expired key keeps status 'active' until
+        // markExpiredKeys() runs, and used to go on signing in the meantime.
+        (0, crypto_1.assertKeyUsable)(result.meta);
+        if (!result.meta.usage.some(u => u === 'signing' || u === 'both')) {
+            throw new Error(`Key is not registered for signing: ${keyId} (usage: ${result.meta.usage.join(', ')})`);
+        }
         // Get suite and sign
         const suite = this.suiteRegistry.getSuite(result.meta.suiteId);
         // Hash the message (consistent with signAgentResponse)
@@ -96,18 +120,29 @@ class DefaultKeySDK {
     }
     /**
      * Verify a signature.
+     *
+     * By default this is the cryptographic check only: a signature made by a
+     * key that has since been rotated, expired or revoked still verifies, which
+     * is what verifying a historical signature needs. Pass `keyStatus` to also
+     * require something of the key's state now.
      */
-    async verifySignature(keyId, message, signature) {
+    async verifySignature(keyId, message, signature, options = {}) {
         const result = await this.keyRegistry.getPublicKey(keyId);
         if (!result) {
             return false;
         }
-        const suite = this.suiteRegistry.getSuite(result.meta.suiteId);
-        // Hash the message
-        const hashAlg = this.getHashAlgorithm(result.meta.suiteId);
-        const messageHash = await (0, crypto_1.hashBytes)(message, hashAlg);
+        if (!statusAllows(result.meta, options.keyStatus ?? 'any')) {
+            return false;
+        }
+        return this.verifyAgainst(result.meta, result.publicKey, message, signature);
+    }
+    /** The cryptographic check alone. Anything but a strict `true` is a failure. */
+    async verifyAgainst(meta, publicKey, message, signature) {
         try {
-            return await suite.verify(result.publicKey, messageHash, signature);
+            const suite = this.suiteRegistry.getSuite(meta.suiteId);
+            const hashAlg = this.getHashAlgorithm(meta.suiteId);
+            const messageHash = await (0, crypto_1.hashBytes)(message, hashAlg);
+            return (await suite.verify(publicKey, messageHash, signature)) === true;
         }
         catch {
             return false;
@@ -117,20 +152,18 @@ class DefaultKeySDK {
      * List keys for an agent.
      */
     async listKeysForAgent(agentId, activeOnly = true) {
+        assertAgentId(agentId);
         const keys = activeOnly
             ? await this.keyRegistry.listActiveKeys()
             : await this.keyRegistry.listKeys();
-        // Filter by agentId prefix
-        const agentKeys = keys.filter(meta => meta.keyId.startsWith(`${agentId}:`));
+        // Exact ownership, not a prefix match (see agentIdOfKey)
+        const agentKeys = keys.filter(meta => (0, crypto_1.agentIdOfKey)(meta.keyId) === agentId);
         // Convert to KeyRecords
         const records = [];
         for (const meta of agentKeys) {
             const result = await this.keyRegistry.getPublicKey(meta.keyId);
             if (result) {
-                records.push({
-                    meta: result.meta,
-                    publicKey: result.publicKey,
-                });
+                records.push(toRecord(result.meta, result.publicKey));
             }
         }
         return records;
@@ -155,39 +188,87 @@ class DefaultKeySDK {
     }
     /**
      * Rotate all keys for an agent.
+     *
+     * Each replacement gets its predecessor's lifetime again, counted from now
+     * (or `options.expiresAt`); it does not inherit the old expiry instant.
+     *
+     * A key derived from a seed cannot be re-derived here, because the SDK does
+     * not keep seeds. By default the call refuses, before changing anything,
+     * rather than silently swapping a recoverable key for a random one. See
+     * {@link RotateAgentKeysOptions.derivedKeys}.
      */
-    async rotateAgentKeys(agentId) {
+    async rotateAgentKeys(agentId, options = {}) {
+        const derivedPolicy = options.derivedKeys ?? 'error';
         const activeKeys = await this.listKeysForAgent(agentId, true);
-        const newKeys = [];
+        // Decide everything before changing anything.
+        const toRotate = [];
         for (const keyRecord of activeKeys) {
-            // Generate new keypair
+            // Resolves the suite now, so an unknown suite fails before any rotation.
+            this.suiteRegistry.getSuite(keyRecord.meta.suiteId);
+            if (keyRecord.meta.derivation) {
+                if (derivedPolicy === 'error') {
+                    throw new Error(`Key ${keyRecord.meta.keyId} was derived from a seed ` +
+                        `(path ${keyRecord.meta.derivation.path || 'unknown'}). Rotating it here would ` +
+                        `replace it with a random key that the mnemonic cannot recover. Derive the ` +
+                        `successor yourself with createKeyFromMnemonic at a new path, or pass ` +
+                        `{ derivedKeys: 'skip' } or { derivedKeys: 'randomize' }. No keys were rotated.`);
+                }
+                if (derivedPolicy === 'skip')
+                    continue;
+            }
+            toRotate.push(keyRecord);
+        }
+        // Generate every replacement before committing any, so a failing suite
+        // cannot leave the agent half rotated. The commits below are then one
+        // registry rotation per key; they are not a single transaction, so a
+        // storage failure part-way through leaves the earlier keys rotated.
+        const replacements = [];
+        for (const keyRecord of toRotate) {
             const suite = this.suiteRegistry.getSuite(keyRecord.meta.suiteId);
-            const newKeypair = await suite.generateKeypair();
-            // Generate new keyId (increment counter)
-            const counter = await this.getNextCounter(agentId);
-            const suiteName = keyRecord.meta.suiteId.split('-')[0];
-            const newKeyId = `${agentId}:pk-${suiteName}-${counter}`;
-            // Rotate
-            const newMeta = await this.keyRegistry.rotateKey(keyRecord.meta.keyId, newKeyId, newKeypair);
-            newKeys.push({
-                meta: newMeta,
-                publicKey: newKeypair.publicKey,
-            });
+            replacements.push(await suite.generateKeypair());
+        }
+        const newKeys = [];
+        for (const [i, keyRecord] of toRotate.entries()) {
+            const newKeypair = replacements[i];
+            const newMeta = await this.registerUnderFreshId(agentId, keyRecord.meta.suiteId, newKeyId => this.keyRegistry.rotateKey(keyRecord.meta.keyId, newKeyId, newKeypair, {
+                expiresAt: options.expiresAt,
+            }));
+            newKeys.push(toRecord(newMeta, newKeypair.publicKey));
         }
         return newKeys;
     }
     /**
      * Get or create key (idempotent).
+     *
+     * Concurrent calls on this SDK instance for the same agent and suite share
+     * one creation. Two SDK instances (or processes) on one storage backend can
+     * still each create a key; that needs a lock in the backend.
      */
     async getOrCreateKey(agentId, profile, options = {}) {
-        // Check if key exists
-        const existingKeys = await this.listKeysForAgent(agentId, true);
-        const primaryKey = existingKeys.find(k => k.meta.suiteId === profile.primarySignatureSuite);
-        if (primaryKey) {
-            return primaryKey;
-        }
-        // Create new key
-        return await this.createKey(agentId, profile, options);
+        assertAgentId(agentId);
+        const slot = JSON.stringify([agentId, profile.primarySignatureSuite]);
+        const pending = this.getOrCreateInFlight.get(slot);
+        if (pending) {
+            const record = await pending;
+            return toRecord(record.meta, record.publicKey);
+        }
+        const work = (async () => {
+            // Check if key exists
+            const existingKeys = await this.listKeysForAgent(agentId, true);
+            const primaryKey = existingKeys.find(k => k.meta.suiteId === profile.primarySignatureSuite);
+            if (primaryKey) {
+                return primaryKey;
+            }
+            // Create new key
+            return await this.createKey(agentId, profile, options);
+        })();
+        this.getOrCreateInFlight.set(slot, work);
+        try {
+            return await work;
+        }
+        finally {
+            this.getOrCreateInFlight.delete(slot);
+        }
     }
     /**
      * Create both primary and secondary keys for an agent.
@@ -196,6 +277,7 @@ class DefaultKeySDK {
         if (!profile.secondarySignatureSuite) {
             throw new Error('secondarySignatureSuite is required to create dual signature keys');
         }
+        this.assertDualProfile(profile);
         const primaryKey = await this.createKey(agentId, {
             primarySignatureSuite: profile.primarySignatureSuite,
         }, options);
@@ -211,6 +293,7 @@ class DefaultKeySDK {
         if (!profile.secondarySignatureSuite) {
             throw new Error('secondarySignatureSuite is required to create dual signature keys');
         }
+        this.assertDualProfile(profile);
         const primaryKey = await this.getOrCreateKey(agentId, {
             primarySignatureSuite: profile.primarySignatureSuite,
         }, options);
@@ -219,6 +302,18 @@ class DefaultKeySDK {
         }, options);
         return { primaryKey, secondaryKey };
     }
+    /**
+     * Fail before creating either key if the pair could not be a hybrid pair:
+     * an unknown suite, or the same suite twice (two ECDSA keys are not a
+     * classical + post-quantum pair, whatever the profile calls them).
+     */
+    assertDualProfile(profile) {
+        this.suiteRegistry.getSuite(profile.primarySignatureSuite);
+        this.suiteRegistry.getSuite(profile.secondarySignatureSuite);
+        if (profile.primarySignatureSuite === profile.secondarySignatureSuite) {
+            throw new Error(`Dual signature keys need two different suites; both are ${profile.primarySignatureSuite}`);
+        }
+    }
     /**
      * Sign with one or more suites for an agent.
      */
@@ -227,7 +322,7 @@ class DefaultKeySDK {
         if (activeKeys.length === 0) {
             throw new Error(`No active keys found for agent: ${agentId}`);
         }
-        const suitesToUse = suites?.length ? suites : Array.from(new Set(activeKeys.map(k => k.meta.suiteId)));
+        const suitesToUse = Array.from(new Set(suites?.length ? suites : activeKeys.map(k => k.meta.suiteId)));
         const signatures = [];
         for (const suiteId of suitesToUse) {
             const key = activeKeys.find(k => k.meta.suiteId === suiteId);
@@ -240,27 +335,92 @@ class DefaultKeySDK {
         return { signatures };
     }
     /**
-     * Verify multiple signatures for an agent.
+     * Verify a set of signatures as a hybrid (multi-suite) signature by `agentId`.
+     *
+     * `allValid` is true only when ALL of these hold:
+     * - at least one signature was supplied;
+     * - every supplied signature is by a key that belongs to `agentId`, names
+     *   that key's real suite, passes the key-status policy, and verifies;
+     * - every REQUIRED suite has such a signature.
+     *
+     * The required suites come from the verifier: `options.requiredSuites`, or
+     * by default the suites of the agent's currently usable keys in this SDK's
+     * registry. They are never read from `signatures`. The check walks the
+     * required suites and looks each one up among the valid signatures, so an
+     * empty list, or one that merely omits the post-quantum signature, is
+     * refused instead of passing because everything in it happens to be valid.
      */
-    async verifyWithSuites(agentId, message, signatures) {
+    async verifyWithSuites(agentId, message, signatures, options = {}) {
+        assertAgentId(agentId);
+        const keyStatus = options.keyStatus ?? 'not-revoked';
+        const requiredSuites = Array.from(new Set(options.requiredSuites ??
+            (await this.listKeysForAgent(agentId, true)).map(k => k.meta.suiteId)));
+        const refuse = (error, results = []) => ({
+            results,
+            allValid: false,
+            requiredSuites,
+            missingSuites: requiredSuites.filter(s => !results.some(r => r.valid && r.suiteId === s)),
+            error,
+        });
+        if (!Array.isArray(signatures)) {
+            return refuse('signatures must be an array');
+        }
         const results = [];
         for (const entry of signatures) {
+            const suiteId = String(entry?.suiteId);
+            const keyId = String(entry?.keyId);
+            const fail = (error) => results.push({ suiteId, keyId, valid: false, error });
             try {
-                const valid = await this.verifySignature(entry.keyId, message, entry.signature);
-                results.push({ suiteId: entry.suiteId, keyId: entry.keyId, valid });
+                if ((0, crypto_1.agentIdOfKey)(keyId) !== agentId) {
+                    fail(`Key does not belong to agent '${agentId}'`);
+                    continue;
+                }
+                const key = await this.keyRegistry.getPublicKey(keyId);
+                if (!key) {
+                    fail('Key not found');
+                    continue;
+                }
+                if (key.meta.suiteId !== suiteId) {
+                    fail(`Suite mismatch: key is ${key.meta.suiteId}, signature claims ${suiteId}`);
+                    continue;
+                }
+                if (!statusAllows(key.meta, keyStatus)) {
+                    fail(`Key status not accepted (status: ${key.meta.status ?? 'active'}, policy: ${keyStatus})`);
+                    continue;
+                }
+                if (!(entry.signature instanceof Uint8Array)) {
+                    fail('Signature must be a Uint8Array');
+                    continue;
+                }
+                const valid = await this.verifyAgainst(key.meta, key.publicKey, message, entry.signature);
+                if (valid) {
+                    results.push({ suiteId, keyId, valid: true });
+                }
+                else {
+                    fail('Signature verification failed');
+                }
             }
             catch (error) {
-                results.push({
-                    suiteId: entry.suiteId,
-                    keyId: entry.keyId,
-                    valid: false,
-                    error: error.message,
-                });
+                fail(error instanceof Error ? error.message : String(error));
             }
         }
+        if (requiredSuites.length === 0) {
+            return refuse(`No required suites: agent '${agentId}' has no usable keys and options.requiredSuites was not given`, results);
+        }
+        if (results.length === 0) {
+            return refuse('No signatures supplied', results);
+        }
+        // Walk the REQUIRED suites and look each up among the valid signatures.
+        const missingSuites = requiredSuites.filter(required => !results.some(r => r.valid && r.suiteId === required));
+        const everySuppliedValid = results.every(r => r.valid === true);
         return {
             results,
-            allValid: results.every(r => r.valid),
+            allValid: everySuppliedValid && missingSuites.length === 0,
+            requiredSuites,
+            missingSuites,
+            ...(missingSuites.length > 0
+                ? { error: `No valid signature for required suite(s): ${missingSuites.join(', ')}` }
+                : {}),
         };
     }
     /**
@@ -280,22 +440,29 @@ class DefaultKeySDK {
      *
      * @param agentId Agent identifier
      * @param profile Crypto profile (must use derivation-capable suite)
-     * @param mnemonic BIP39 mnemonic phrase
+     * @param mnemonic BIP39 mnemonic phrase (words and checksum are validated)
      * @param path BIP32 derivation path (default: "m/44'/0'/0'/0/0")
      * @param passphrase Optional BIP39 passphrase
      * @param options Additional key creation options
      * @returns KeyRecord with derived key
+     * @throws if the mnemonic has an unknown word, a wrong word count or a bad checksum
      */
     async createKeyFromMnemonic(agentId, profile, mnemonic, path = crypto_1.BIP32Derivation.bitcoinPath(0, 0, 0), passphrase, options = {}) {
         const bip32 = new crypto_1.BIP32Derivation();
         const seed = bip32.mnemonicToSeed(mnemonic, passphrase);
-        return await this.createKey(agentId, profile, {
-            ...options,
-            derivationContext: {
-                seed,
-                path,
-            },
-        });
+        try {
+            return await this.createKey(agentId, profile, {
+                ...options,
+                derivationContext: {
+                    seed,
+                    path,
+                },
+            });
+        }
+        finally {
+            // The seed is the root of every key in the wallet; do not leave it behind.
+            seed.fill(0);
+        }
     }
     /**
      * Get available capabilities for a specific suite.
@@ -327,10 +494,36 @@ class DefaultKeySDK {
             .map(suite => suite.suiteId);
     }
     /**
-     * Create a Bitcoin wallet key from mnemonic (convenience method).
+     * Create a wallet key from a mnemonic at an explicit BIP44 coin type:
+     * `m/44'/coinType'/account'/change/index`.
+     *
+     * The coin type is required and has no default. It decides which wallets
+     * will find the key again: Bitcoin (BTC) is 0, Bitcoin SV is 236.
+     *
+     * @param agentId Agent identifier
+     * @param mnemonic BIP39 mnemonic phrase (words and checksum are validated)
+     * @param path Coin type and position in the BIP44 tree
+     * @param options Additional key creation options
+     * @returns KeyRecord with the derived secp256k1 key
+     */
+    async createWalletKey(agentId, mnemonic, path, options = {}) {
+        if (!path || typeof path.coinType !== 'number') {
+            throw new Error('createWalletKey requires path.coinType (SLIP-44: Bitcoin is 0, Bitcoin SV is 236)');
+        }
+        const derivationPath = crypto_1.BIP32Derivation.bip44Path(path.coinType, path.account ?? 0, path.change ? 1 : 0, path.index ?? 0);
+        return this.createKeyFromMnemonic(agentId, { primarySignatureSuite: 'bsv-ecdsa-secp256k1' }, mnemonic, derivationPath, path.passphrase, options);
+    }
+    /**
+     * Create a wallet key from mnemonic at the Bitcoin (BTC) BIP44 path:
+     * m/44'/0'/account'/change/addressIndex
      *
-     * Uses standard BIP44 Bitcoin path: m/44'/0'/account'/change/addressIndex
+     * NOTE: coin type 0 is BTC. A Bitcoin SV wallet restoring the same mnemonic
+     * looks under coin type 236 and will not find this key. The path is left
+     * as it is because changing it would move every key already created with
+     * this method. For new code use {@link createWalletKey}, which makes the
+     * coin type explicit.
      *
+     * @deprecated Use createWalletKey(agentId, mnemonic, { coinType, ... }).
      * @param agentId Agent identifier
      * @param mnemonic BIP39 mnemonic phrase
      * @param accountIndex Account index (default: 0)
@@ -352,6 +545,34 @@ class DefaultKeySDK {
         }
         return 'sha256';
     }
+    /**
+     * Helper: register a key under the agent's next free key ID.
+     *
+     * The counter is cached per SDK instance, so another instance (or process)
+     * on the same storage can have taken the ID already. The registry refuses
+     * to overwrite; on that refusal the counter is re-read from storage and the
+     * next ID is tried. Before, the second writer silently replaced the first
+     * writer's private key.
+     */
+    async registerUnderFreshId(agentId, suiteId, register) {
+        // 'ml' for every ml-dsa suite, 'bsv' for bsv-ecdsa-secp256k1
+        const suiteName = suiteId.split('-')[0].replace(/[^A-Za-z0-9]/g, '') || 'key';
+        for (let attempt = 0; attempt < MAX_KEY_ID_ATTEMPTS; attempt++) {
+            const counter = await this.getNextCounter(agentId);
+            const keyId = `${agentId}:pk-${suiteName}-${counter}`;
+            try {
+                return await register(keyId);
+            }
+            catch (error) {
+                if (!(error instanceof crypto_1.KeyAlreadyExistsError))
+                    throw error;
+                // Someone else holds that ID: forget the cached counter and re-read.
+                this.counterInitialized.delete(agentId);
+                this.keyCounter.delete(agentId);
+            }
+        }
+        throw new Error(`Could not allocate a key ID for agent '${agentId}' after ${MAX_KEY_ID_ATTEMPTS} attempts`);
+    }
     /**
      * Helper: Get next counter for an agent.
      */
@@ -359,19 +580,25 @@ class DefaultKeySDK {
         if (!this.counterInitialized.has(agentId)) {
             if (!this.counterInitPromises.has(agentId)) {
                 const initPromise = (async () => {
-                    const existing = await this.keyRegistry.listKeys();
-                    const max = existing.reduce((acc, meta) => {
-                        if (!meta.keyId.startsWith(`${agentId}:pk-`))
-                            return acc;
-                        const match = meta.keyId.match(/:pk-[^-]+-(\d+)$/);
-                        if (!match)
-                            return acc;
-                        const num = parseInt(match[1], 10);
-                        return Number.isFinite(num) ? Math.max(acc, num) : acc;
-                    }, 0);
-                    this.keyCounter.set(agentId, max);
-                    this.counterInitialized.add(agentId);
-                    this.counterInitPromises.delete(agentId);
+                    try {
+                        const existing = await this.keyRegistry.listKeys();
+                        const max = existing.reduce((acc, meta) => {
+                            if ((0, crypto_1.agentIdOfKey)(meta.keyId) !== agentId)
+                                return acc;
+                            const local = meta.keyId.slice(agentId.length + 1);
+                            const match = COUNTER_SUFFIX.exec(local);
+                            if (!match)
+                                return acc;
+                            const num = parseInt(match[1], 10);
+                            return Number.isSafeInteger(num) ? Math.max(acc, num) : acc;
+                        }, 0);
+                        // A counter handed out while this scan ran must not be reused.
+                        this.keyCounter.set(agentId, Math.max(max, this.keyCounter.get(agentId) || 0));
+                        this.counterInitialized.add(agentId);
+                    }
+                    finally {
+                        this.counterInitPromises.delete(agentId);
+                    }
                 })();
                 this.counterInitPromises.set(agentId, initPromise);
             }
@@ -426,9 +653,17 @@ exports.DefaultKeySDK = DefaultKeySDK;
 function createKeySDK(config) {
     const keyRegistry = config?.keyRegistry || new crypto_1.KeyRegistry(new crypto_1.InMemoryKeyStorage());
     const suiteRegistry = config?.suiteRegistry || new crypto_1.SignatureSuiteRegistry();
-    // Register default suites if not provided
+    // Register default suites if not provided.
+    //
+    // All three ML-DSA levels are registered, not just 87. The README documents
+    // ml-dsa-65 as the recommended default and ml-dsa-44 for constrained
+    // devices; registering only 87 made every one of those examples throw
+    // `Unknown signature suite` at runtime, with no way for a caller to fix it
+    // -- SignatureSuiteRegistry is not re-exported from this package.
     if (!config?.suiteRegistry) {
         suiteRegistry.register(new crypto_1.BsvEcdsaSuite());
+        suiteRegistry.register(new crypto_1.MlDsa44Suite());
+        suiteRegistry.register(new crypto_1.MlDsa65Suite());
         suiteRegistry.register(new crypto_1.MlDsa87Suite());
     }
     return new DefaultKeySDK({