@pomade/core 0.0.7 → 0.0.9

package/dist/signer.js

@@ -1,11 +1,17 @@
 import { Lib } from "@frostr/bifrost";
 import { randomBytes, bytesToHex } from "@noble/hashes/utils.js";
-import { now, filter, removeUndefined, append, ms, uniq, between, call, int, ago, MINUTE, HOUR, YEAR, } from "@welshman/lib";
-import { getPubkey, verifyEvent, getTagValue, HTTP_AUTH } from "@welshman/util";
+import { not, now, filter, remove, removeUndefined, append, ms, uniq, between, call, int, ago, MINUTE, HOUR, YEAR, } from "@welshman/lib";
+import { verifyEvent, getTagValue, HTTP_AUTH } from "@welshman/util";
 import { Method, isPasswordAuth, isOTPAuth } from "./schema.js";
 import { RPC } from "./rpc.js";
 import { hashEmail, encodeChallenge, debug } from "./util.js";
 import { isChallengeRequest, isEcdhRequest, isLoginSelect, isLoginStart, isRecoverySetup, isRecoverySelect, isRecoveryStart, isRegisterRequest, isSessionDelete, isSessionList, isSignRequest, makeEcdhResult, makeLoginOptions, makeLoginResult, makeRecoverySetupResult, makeRecoveryOptions, makeRecoveryResult, makeRegisterResult, makeSessionDeleteResult, makeSessionListResult, makeSignResult, } from "./message.js";
+import { isRateLimited, recordAttempt, getRateLimitResetTime, cleanupRateLimits, } from "./ratelimit.js";
+// Rate limiting for client requests (sign + ecdh combined)
+const CLIENT_REQUEST_RATE_LIMIT = {
+    maxAttempts: 100,
+    windowSeconds: int(1, MINUTE),
+};
 // Utils
 function makeSessionItem(session) {
     return {
@@ -22,27 +28,41 @@ function makeSessionItem(session) {
 export class Signer {
     options;
     rpc;
-    pubkey;
     intervals;
     logins;
     sessions;
     recoveries;
     challenges;
     sessionsByEmailHash;
+    rateLimitByEmailHash;
+    rateLimitByChallengeHash;
+    rateLimitByClient;
+    rateLimitConfig;
     constructor(options) {
         this.options = options;
-        this.pubkey = getPubkey(options.secret);
         this.logins = options.storage.collection("logins");
         this.sessions = options.storage.collection("sessions");
         this.recoveries = options.storage.collection("recoveries");
         this.challenges = options.storage.collection("challenges");
         this.sessionsByEmailHash = options.storage.collection("sessionsByEmailHash");
-        this.rpc = new RPC(options.secret, options.relays);
+        this.rateLimitByEmailHash = options.storage.collection("rateLimitByEmailHash");
+        this.rateLimitByChallengeHash = options.storage.collection("rateLimitByChallengeHash");
+        this.rateLimitByClient = options.storage.collection("rateLimitByClient");
+        // Default rate limits (conservative but reasonable)
+        this.rateLimitConfig = {
+            // 5 auth attempts per email_hash per 5 minutes
+            auth: { maxAttempts: 5, windowSeconds: int(5, MINUTE) },
+            // 3 challenge requests per email_hash per 5 minutes
+            challenge: { maxAttempts: 3, windowSeconds: int(5, MINUTE) },
+            ...options.rateLimits,
+        };
+        this.rpc = new RPC(options.signer, options.relays);
         this.rpc.subscribe(message => {
             // Ignore events with weird timestamps
             if (!between([now() - int(1, HOUR), now() + int(1, HOUR)], message.event.created_at)) {
                 return debug("[signer]: ignoring event", message.event.id);
             }
+            debug("[signer]: received event", message);
             if (isRegisterRequest(message))
                 this.handleRegisterRequest(message);
             if (isRecoverySetup(message))
@@ -66,10 +86,10 @@ export class Signer {
             if (isSessionDelete(message))
                 this.handleSessionDelete(message);
         });
-        // Periodically clean up recovery requests
+        // Periodically clean up recovery requests and rate limits
         this.intervals = [
             setInterval(async () => {
-                debug("[signer]: cleaning up logins and recoveries");
+                debug("[signer]: cleaning up logins, recoveries, and rate limits");
                 for (const [client, recovery] of await this.recoveries.entries()) {
                     if (recovery.event.created_at < ago(15, MINUTE))
                         await this.recoveries.delete(client);
@@ -82,6 +102,10 @@ export class Signer {
                     if (challenge.event.created_at < ago(15, MINUTE))
                         await this.challenges.delete(client);
                 }
+                // Clean up rate limit buckets
+                await cleanupRateLimits(this.rateLimitByEmailHash, this.rateLimitConfig.auth.windowSeconds);
+                await cleanupRateLimits(this.rateLimitByChallengeHash, this.rateLimitConfig.challenge.windowSeconds);
+                await cleanupRateLimits(this.rateLimitByClient, CLIENT_REQUEST_RATE_LIMIT.windowSeconds);
             }, ms(int(5, MINUTE))),
         ];
         // Immediately clean up old sessions
@@ -97,35 +121,61 @@ export class Signer {
         this.intervals.forEach(clearInterval);
     }
     // Internal utils
+    async _checkAndRecordRateLimit(client) {
+        const bucket = await this.rateLimitByClient.get(client);
+        if (isRateLimited(bucket, CLIENT_REQUEST_RATE_LIMIT)) {
+            const resetTime = getRateLimitResetTime(bucket, CLIENT_REQUEST_RATE_LIMIT);
+            debug(`[signer]: rate limit exceeded for client ${client.slice(0, 8)}, reset in ${resetTime}s`);
+            return false;
+        }
+        // Record the attempt
+        const updatedBucket = recordAttempt(bucket, CLIENT_REQUEST_RATE_LIMIT);
+        await this.rateLimitByClient.set(client, updatedBucket);
+        return true;
+    }
     async _getAuthenticatedSessions(auth) {
+        // Check rate limit for auth attempts
+        const bucket = await this.rateLimitByEmailHash.get(auth.email_hash);
+        if (isRateLimited(bucket, this.rateLimitConfig.auth)) {
+            const resetTime = getRateLimitResetTime(bucket, this.rateLimitConfig.auth);
+            debug(`[signer]: rate limit exceeded for email_hash ${auth.email_hash.slice(0, 8)}, reset in ${resetTime}s`);
+            return [];
+        }
         const index = await this.sessionsByEmailHash.get(auth.email_hash);
+        let sessions = [];
         if (index) {
             if (isPasswordAuth(auth)) {
-                return filter(session => session?.password_hash === auth.password_hash, await Promise.all(index.clients.map(client => this.sessions.get(client))));
+                sessions = filter(session => session?.password_hash === auth.password_hash, await Promise.all(index.clients.map(client => this.sessions.get(client))));
             }
             if (isOTPAuth(auth)) {
                 const challenge = await this.challenges.get(auth.email_hash);
                 if (challenge) {
                     await this.challenges.delete(auth.email_hash);
                     if (auth.otp === challenge.otp) {
-                        return removeUndefined(await Promise.all(index.clients.map(client => this.sessions.get(client))));
+                        sessions = removeUndefined(await Promise.all(index.clients.map(client => this.sessions.get(client))));
                     }
                 }
             }
         }
-        return [];
+        // Record failed authentication attempt for rate limiting
+        if (sessions.length === 0) {
+            const updatedBucket = recordAttempt(bucket, this.rateLimitConfig.auth);
+            await this.rateLimitByEmailHash.set(auth.email_hash, updatedBucket);
+        }
+        return sessions;
     }
-    _isNip98AuthValid(auth, method) {
+    async _isNip98AuthValid(auth, method) {
+        const pubkey = await this.options.signer.getPubkey();
         return (verifyEvent(auth) &&
             auth.kind === HTTP_AUTH &&
             auth.created_at > ago(15) &&
             auth.created_at < now() + 5 &&
-            getTagValue("u", auth.tags) === this.pubkey &&
+            getTagValue("u", auth.tags) === pubkey &&
             getTagValue("method", auth.tags) === method);
     }
     async _checkKeyReuse(event) {
         if (await this.sessions.get(event.pubkey)) {
-            debug("[signer]: session key re-used", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: session key re-used`);
             return this.rpc.channel(event.pubkey, false).send(makeRecoveryOptions({
                 ok: false,
                 message: "Do not re-use session keys.",
@@ -133,7 +183,7 @@ export class Signer {
             }));
         }
         if (await this.recoveries.get(event.pubkey)) {
-            debug("[signer]: recovery key re-used", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: recovery key re-used`);
             return this.rpc.channel(event.pubkey, false).send(makeRecoveryOptions({
                 ok: false,
                 message: "Do not re-use recovery keys.",
@@ -141,7 +191,7 @@ export class Signer {
             }));
         }
         if (await this.logins.get(event.pubkey)) {
-            debug("[signer]: login key re-used", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: login key re-used`);
             return this.rpc.channel(event.pubkey, false).send(makeRecoveryOptions({
                 ok: false,
                 message: "Do not re-use login keys.",
@@ -149,9 +199,38 @@ export class Signer {
             }));
         }
     }
+    async _addSession(client, session) {
+        await this.sessions.set(client, session);
+        if (session.email_hash) {
+            let index = await this.sessionsByEmailHash.get(session.email_hash);
+            if (!index) {
+                index = { clients: [] };
+            }
+            await this.sessionsByEmailHash.set(session.email_hash, {
+                clients: append(client, index.clients),
+            });
+        }
+    }
+    async _deleteSession(client) {
+        const session = await this.sessions.get(client);
+        if (session) {
+            if (session.email_hash) {
+                const index = await this.sessionsByEmailHash.get(session.email_hash);
+                if (index) {
+                    const clients = remove(client, index.clients);
+                    if (clients.length === 0) {
+                        await this.sessionsByEmailHash.delete(session.email_hash);
+                    }
+                    else {
+                        await this.sessionsByEmailHash.set(session.email_hash, { clients });
+                    }
+                }
+            }
+            await this.sessions.delete(client);
+        }
+    }
     // Registration
     async handleRegisterRequest({ payload, event }) {
-        debug("[signer]: attempting to register session", event.pubkey);
         return this.options.storage.tx(async () => {
             const { group, share, recovery } = payload;
             const cb = (ok, message) => this.rpc
@@ -160,26 +239,26 @@ export class Signer {
             if (await this._checkKeyReuse(event))
                 return;
             if (!between([0, group.commits.length], group.threshold)) {
-                debug("[signer]: invalid group threshold", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: invalid group threshold`);
                 return cb(false, "Invalid group threshold.");
             }
             if (!Lib.is_group_member(group, share)) {
-                debug("[signer]: share does not belong to the provided group", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: share does not belong to the provided group`);
                 return cb(false, "Share does not belong to the provided group.");
             }
             if (uniq(group.commits.map(c => c.idx)).length !== group.commits.length) {
-                debug("[signer]: group contains duplicate member indices", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: group contains duplicate member indices`);
                 return cb(false, "Group contains duplicate member indices.");
             }
             if (!group.commits.find(c => c.idx === share.idx)) {
-                debug("[signer]: share index not found in group commits", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: share index not found in group commits`);
                 return cb(false, "Share index not found in group commits.");
             }
             if (await this.sessions.get(event.pubkey)) {
-                debug("[signer]: client is already registered", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: client is already registered`);
                 return cb(false, "Client is already registered.");
             }
-            await this.sessions.set(event.pubkey, {
+            await this._addSession(event.pubkey, {
                 client: event.pubkey,
                 event,
                 share,
@@ -187,7 +266,7 @@ export class Signer {
                 recovery,
                 last_activity: now(),
             });
-            debug("[signer]: registered", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: registered`);
             return cb(true, "Your key has been registered");
         });
     }
@@ -196,7 +275,7 @@ export class Signer {
         return this.options.storage.tx(async () => {
             const session = await this.sessions.get(event.pubkey);
             if (!session) {
-                debug("[signer]: no session found for recovery setup", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: no session found for recovery setup`);
                 return this.rpc.channel(event.pubkey, false).send(makeRecoverySetupResult({
                     ok: false,
                     message: "No session found.",
@@ -204,7 +283,7 @@ export class Signer {
                 }));
             }
             if (!session.recovery) {
-                debug("[signer]: recovery is disabled for session", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: recovery is disabled for session`);
                 return this.rpc.channel(event.pubkey, false).send(makeRecoverySetupResult({
                     ok: false,
                     message: "Recovery is disabled on this session.",
@@ -214,7 +293,7 @@ export class Signer {
             // recovery method has to be bound at (or shorly after) session, otherwise an attacker with access
             // to any session could escalate permissions by setting up their own recovery method
             if (session.event.created_at < ago(15, MINUTE)) {
-                debug("[signer]: recovery method set too late", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: recovery method set too late`);
                 return this.rpc.channel(event.pubkey, false).send(makeRecoverySetupResult({
                     ok: false,
                     message: "Recovery method must be set within 5 minutes of session.",
@@ -222,7 +301,7 @@ export class Signer {
                 }));
             }
             if (session.email) {
-                debug("[signer]: recovery is already set", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: recovery is already set`);
                 return this.rpc.channel(event.pubkey, false).send(makeRecoverySetupResult({
                     ok: false,
                     message: "Recovery has already been initialized.",
@@ -230,7 +309,7 @@ export class Signer {
                 }));
             }
             if (!payload.password_hash.match(/^[a-f0-9]{64}$/)) {
-                debug("[signer]: invalid password_hash provided on setup", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: invalid password_hash provided on setup`);
                 return this.rpc.channel(event.pubkey, false).send(makeRecoverySetupResult({
                     ok: false,
                     message: "Recovery method password hash must be an argon2id hash of user email and password.",
@@ -238,17 +317,16 @@ export class Signer {
                 }));
             }
             const { email, password_hash } = payload;
-            const email_hash = await hashEmail(email, this.pubkey);
-            const index = (await this.sessionsByEmailHash.get(email_hash)) || { clients: [] };
-            await this.sessions.set(event.pubkey, {
+            const pubkey = await this.options.signer.getPubkey();
+            const email_hash = await hashEmail(email, pubkey);
+            await this._addSession(event.pubkey, {
                 ...session,
                 last_activity: now(),
                 email,
                 email_hash,
                 password_hash,
             });
-            await this.sessionsByEmailHash.set(email_hash, { clients: append(event.pubkey, index.clients) });
-            debug("[signer]: recovery method initialized", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: recovery method initialized`);
             this.rpc.channel(event.pubkey, false).send(makeRecoverySetupResult({
                 ok: true,
                 message: "Recovery method successfully initialized.",
@@ -257,16 +335,31 @@ export class Signer {
         });
     }
     async handleChallengeRequest({ payload, event }) {
+        // Check rate limit for challenge requests per email_hash
+        const bucket = await this.rateLimitByChallengeHash.get(payload.email_hash);
+        if (isRateLimited(bucket, this.rateLimitConfig.challenge)) {
+            const resetTime = getRateLimitResetTime(bucket, this.rateLimitConfig.challenge);
+            debug(`[signer]: challenge rate limit exceeded for email_hash ${payload.email_hash.slice(0, 8)}, reset in ${resetTime}s`);
+            return;
+        }
         const index = await this.sessionsByEmailHash.get(payload.email_hash);
         if (index && index.clients.length > 0) {
             const session = await this.sessions.get(index.clients[0]);
             if (session?.email) {
-                const otp = bytesToHex(randomBytes(12));
-                const challenge = encodeChallenge(this.pubkey, otp);
+                // Record challenge request for rate limiting
+                const updatedBucket = recordAttempt(bucket, this.rateLimitConfig.challenge);
+                await this.rateLimitByChallengeHash.set(payload.email_hash, updatedBucket);
+                const otp = bytesToHex(randomBytes(8));
+                const pubkey = await this.options.signer.getPubkey();
+                const challenge = encodeChallenge(pubkey, otp);
                 await this.challenges.set(payload.email_hash, { otp, event });
                 this.options.sendChallenge({ email: session.email, challenge });
+                debug(`[client ${event.pubkey.slice(0, 8)}]: challenge sent for ${payload.email_hash}`);
             }
         }
+        else {
+            debug(`[client ${event.pubkey.slice(0, 8)}]: no session found for ${payload.email_hash}`);
+        }
     }
     // Recovery
     async handleRecoveryStart({ payload, event }) {
@@ -274,14 +367,14 @@ export class Signer {
             return;
         const sessions = await this._getAuthenticatedSessions(payload.auth);
         if (sessions.length === 0) {
-            debug("[signer]: no sessions found for recovery", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: no sessions found for recovery`);
             return this.rpc.channel(event.pubkey, false).send(makeRecoveryOptions({
                 ok: false,
                 message: "No sessions found.",
                 prev: event.id,
             }));
         }
-        debug("[signer]: sending recovery options", event.pubkey);
+        debug(`[client ${event.pubkey.slice(0, 8)}]: sending recovery options`);
         const clients = sessions.map(s => s.client);
         const items = sessions.map(makeSessionItem);
         await this.recoveries.set(event.pubkey, { event, clients });
@@ -295,7 +388,7 @@ export class Signer {
     async handleRecoverySelect({ payload, event }) {
         const recovery = await this.recoveries.get(event.pubkey);
         if (!recovery) {
-            debug("[signer]: no active recovery found", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: no active recovery found`);
             return this.rpc.channel(event.pubkey, false).send(makeRecoveryResult({
                 ok: false,
                 message: `No active recovery found.`,
@@ -305,7 +398,7 @@ export class Signer {
         // Cleanup right away
         await this.recoveries.delete(event.pubkey);
         if (!recovery.clients.includes(payload.client)) {
-            debug("[signer]: invalid session selected for recovery", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: invalid session selected for recovery`);
             return this.rpc.channel(event.pubkey, false).send(makeRecoveryResult({
                 ok: false,
                 message: `Invalid session selected for recovery.`,
@@ -314,7 +407,7 @@ export class Signer {
         }
         const session = await this.sessions.get(payload.client);
         if (!session) {
-            debug("[signer]: recovery session not found", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: recovery session not found`);
             return this.rpc.channel(event.pubkey, false).send(makeRecoveryResult({
                 ok: false,
                 message: `Recovery session not found.`,
@@ -328,7 +421,7 @@ export class Signer {
             share: session.share,
             prev: event.id,
         }));
-        debug("[signer]: recovery successfully completed", event.pubkey);
+        debug(`[client ${event.pubkey.slice(0, 8)}]: recovery successfully completed`);
     }
     // Login
     async handleLoginStart({ payload, event }) {
@@ -336,14 +429,14 @@ export class Signer {
             return;
         const sessions = await this._getAuthenticatedSessions(payload.auth);
         if (sessions.length === 0) {
-            debug("[signer]: no sessions found for login", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: no sessions found for login`);
             return this.rpc.channel(event.pubkey, false).send(makeLoginOptions({
                 ok: false,
                 message: "No sessions found.",
                 prev: event.id,
             }));
         }
-        debug("[signer]: sending login options", event.pubkey);
+        debug(`[client ${event.pubkey.slice(0, 8)}]: sending login options`);
         const clients = sessions.map(s => s.client);
         const items = sessions.map(makeSessionItem);
         await this.logins.set(event.pubkey, { event, clients });
@@ -357,7 +450,7 @@ export class Signer {
     async handleLoginSelect({ payload, event }) {
         const login = await this.logins.get(event.pubkey);
         if (!login) {
-            debug("[signer]: no active login found", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: no active login found`);
             return this.rpc.channel(event.pubkey, false).send(makeLoginResult({
                 ok: false,
                 message: `No active login found.`,
@@ -367,7 +460,7 @@ export class Signer {
         // Cleanup right away
         await this.logins.delete(event.pubkey);
         if (!login.clients.includes(payload.client)) {
-            debug("[signer]: invalid session selected for login", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: invalid session selected for login`);
             return this.rpc.channel(event.pubkey, false).send(makeLoginResult({
                 ok: false,
                 message: `Invalid session selected for login.`,
@@ -376,19 +469,22 @@ export class Signer {
         }
         const session = await this.sessions.get(payload.client);
         if (!session) {
-            debug("[signer]: login session not found", event.pubkey);
+            debug(`[client ${event.pubkey.slice(0, 8)}]: login session not found`);
             return this.rpc.channel(event.pubkey, false).send(makeLoginResult({
                 ok: false,
                 message: `Login session not found.`,
                 prev: event.id,
             }));
         }
-        await this.sessions.set(event.pubkey, {
+        await this._addSession(event.pubkey, {
             event,
             recovery: true,
             client: event.pubkey,
             share: session.share,
             group: session.group,
+            email: session.email,
+            email_hash: session.email_hash,
+            password_hash: session.password_hash,
             last_activity: now(),
         });
         this.rpc.channel(event.pubkey, false).send(makeLoginResult({
@@ -397,62 +493,98 @@ export class Signer {
             group: session.group,
             prev: event.id,
         }));
-        debug("[signer]: login successfully completed", event.pubkey);
+        debug(`[client ${event.pubkey.slice(0, 8)}]: login successfully completed`);
     }
     // Signing
     async handleSignRequest({ payload, event }) {
-        debug("[signer]: attempting signing flow", event.pubkey);
         return this.options.storage.tx(async () => {
             const session = await this.sessions.get(event.pubkey);
             if (!session) {
-                debug("[signer]: signing failed", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: signing failed - no session found`);
                 return this.rpc.channel(event.pubkey, false).send(makeSignResult({
                     ok: false,
                     message: "No session found for client",
                     prev: event.id,
                 }));
             }
-            const ctx = Lib.get_session_ctx(session.group, payload.request);
-            const partialSignature = Lib.create_psig_pkg(ctx, session.share);
-            await this.sessions.set(event.pubkey, { ...session, last_activity: now() });
-            debug("[signer]: signing complete", event.pubkey);
-            this.rpc.channel(event.pubkey, false).send(makeSignResult({
-                result: partialSignature,
-                ok: true,
-                message: "Successfully signed event",
-                prev: event.id,
-            }));
+            // Check rate limit
+            const allowed = await this._checkAndRecordRateLimit(event.pubkey);
+            if (!allowed) {
+                return this.rpc.channel(event.pubkey, false).send(makeSignResult({
+                    ok: false,
+                    message: "Rate limit exceeded. Please try again later.",
+                    prev: event.id,
+                }));
+            }
+            try {
+                const ctx = Lib.get_session_ctx(session.group, payload.request);
+                const partialSignature = Lib.create_psig_pkg(ctx, session.share);
+                await this.sessions.set(event.pubkey, { ...session, last_activity: now() });
+                debug(`[client ${event.pubkey.slice(0, 8)}]: signing complete`);
+                this.rpc.channel(event.pubkey, false).send(makeSignResult({
+                    result: partialSignature,
+                    ok: true,
+                    message: "Successfully signed event",
+                    prev: event.id,
+                }));
+            }
+            catch (e) {
+                debug(`[client ${event.pubkey.slice(0, 8)}]: signing failed - ${e.message || e}`);
+                return this.rpc.channel(event.pubkey, false).send(makeSignResult({
+                    ok: false,
+                    message: "Failed to sign event",
+                    prev: event.id,
+                }));
+            }
         });
     }
     // Key exchange
     async handleEcdhRequest({ payload, event }) {
-        debug("[signer]: attempting ecdh flow", event.pubkey);
         return this.options.storage.tx(async () => {
             const session = await this.sessions.get(event.pubkey);
             if (!session) {
-                debug("[signer]: ecdh failed", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: ecdh failed - no session found`);
                 return this.rpc.channel(event.pubkey, false).send(makeSignResult({
                     ok: false,
                     message: "No session found for client",
                     prev: event.id,
                 }));
             }
+            // Check rate limit
+            const allowed = await this._checkAndRecordRateLimit(event.pubkey);
+            if (!allowed) {
+                return this.rpc.channel(event.pubkey, false).send(makeEcdhResult({
+                    ok: false,
+                    message: "Rate limit exceeded. Please try again later.",
+                    prev: event.id,
+                }));
+            }
             const { members, ecdh_pk } = payload;
-            const ecdhPackage = Lib.create_ecdh_pkg(members, ecdh_pk, session.share);
-            await this.sessions.set(event.pubkey, { ...session, last_activity: now() });
-            debug("[signer]: ecdh complete", event.pubkey);
-            this.rpc.channel(event.pubkey, false).send(makeEcdhResult({
-                result: ecdhPackage,
-                ok: true,
-                message: "Successfully signed event",
-                prev: event.id,
-            }));
+            try {
+                const ecdhPackage = Lib.create_ecdh_pkg(members, ecdh_pk, session.share);
+                await this.sessions.set(event.pubkey, { ...session, last_activity: now() });
+                debug(`[client ${event.pubkey.slice(0, 8)}]: ecdh complete`);
+                this.rpc.channel(event.pubkey, false).send(makeEcdhResult({
+                    result: ecdhPackage,
+                    ok: true,
+                    message: "Successfully signed event",
+                    prev: event.id,
+                }));
+            }
+            catch (e) {
+                debug(`[client ${event.pubkey.slice(0, 8)}]: ecdh failed - ${e.message || e}`);
+                return this.rpc.channel(event.pubkey, false).send(makeSignResult({
+                    ok: false,
+                    message: "Key derivation failed",
+                    prev: event.id,
+                }));
+            }
         });
     }
     // Session management
     async handleSessionList({ payload, event }) {
-        if (!this._isNip98AuthValid(payload.auth, Method.SessionList)) {
-            debug("[signer]: invalid auth event for session list", event.pubkey);
+        if (not(await this._isNip98AuthValid(payload.auth, Method.SessionList))) {
+            debug(`[client ${event.pubkey.slice(0, 8)}]: invalid auth event for session list`);
             return this.rpc.channel(event.pubkey, false).send(makeSessionListResult({
                 items: [],
                 ok: false,
@@ -460,14 +592,13 @@ export class Signer {
                 prev: event.id,
             }));
         }
-        debug("[signer]: attempting to retrieve session list", event.pubkey);
         const items = [];
         for (const [_, session] of await this.sessions.entries()) {
             if (session.group.group_pk.slice(2) === payload.auth.pubkey) {
                 items.push(makeSessionItem(session));
             }
         }
-        debug("[signer]: successfully retrieved session list", event.pubkey);
+        debug(`[client ${event.pubkey.slice(0, 8)}]: successfully retrieved session list`);
         this.rpc.channel(event.pubkey, false).send(makeSessionListResult({
             items,
             ok: true,
@@ -476,20 +607,19 @@ export class Signer {
         }));
     }
     async handleSessionDelete({ payload, event }) {
-        if (!this._isNip98AuthValid(payload.auth, Method.SessionDelete)) {
-            debug("[signer]: invalid auth event for session deletion", event.pubkey);
+        if (not(await this._isNip98AuthValid(payload.auth, Method.SessionDelete))) {
+            debug(`[client ${event.pubkey.slice(0, 8)}]: invalid auth event for session deletion`);
             return this.rpc.channel(event.pubkey, false).send(makeSessionDeleteResult({
                 ok: false,
                 message: "Failed to delete selected session.",
                 prev: event.id,
             }));
         }
-        debug("[signer]: attempting to delete session", event.pubkey);
         return this.options.storage.tx(async () => {
             const session = await this.sessions.get(payload.client);
             if (session?.group.group_pk.slice(2) === payload.auth.pubkey) {
-                await this.sessions.delete(payload.client);
-                debug("[signer]: deleted session", event.pubkey);
+                await this._deleteSession(payload.client);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: deleted session`, payload.client);
                 this.rpc.channel(event.pubkey, false).send(makeSessionDeleteResult({
                     ok: true,
                     message: "Successfully deleted selected session.",
@@ -497,7 +627,7 @@ export class Signer {
                 }));
             }
             else {
-                debug("[signer]: failed to delete session", event.pubkey);
+                debug(`[client ${event.pubkey.slice(0, 8)}]: failed to delete session`, payload.client);
                 return this.rpc.channel(event.pubkey, false).send(makeSessionDeleteResult({
                     ok: false,
                     message: "Failed to logout selected client.",