fix: prevent crashes from missing keys and history records

Fix unhandled promise rejections and crashes caused by race conditions
in WalletConnect message processing. These changes prevent Lambda
timeouts and 502 errors by gracefully handling expected edge cases.

Changes:

1. crypto.decode() - Handle missing symmetric keys gracefully
   - Wrap generateSharedKey() in try-catch (was outside, causing crashes)
   - Return undefined on decode failure instead of throwing
   - Change error logging to warn (expected race condition)

2. history.resolve() - Handle missing history records gracefully
   - Wrap getRecord() in try-catch to prevent crashes
   - Log warnings instead of errors for missing records
   - Continue processing other messages when record not found

3. engine.onRelayMessage() - Handle undefined payload from decode
   - Check for undefined payload after decode
   - Early return with warning if decode fails
   - Prevents downstream crashes from undefined values

4. engine.onRelayEventResponse() - Handle missing history records
   - Wrap history.get() in try-catch
   - Early return with warning if record not found
   - Prevents crashes when response arrives before request recorded

These fixes address stack traces showing:
- "No matching key. history: <id>" errors
- "onRelayMessage() -> failed to process inbound message" errors
- Lambda 502 "Internal Server Error" responses

All changes maintain backward compatibility and use appropriate
log levels (warn for expected race conditions, error for unexpected).

Author: JFixby

packages/core/src/controllers/crypto.ts

@@ -143,21 +143,22 @@ export class Crypto implements ICrypto {
       const message = decodeTypeTwoEnvelope(encoded, opts?.encoding);
       return safeJsonParse(message);
     }
-    if (isTypeOneEnvelope(params)) {
-      const selfPublicKey = params.receiverPublicKey;
-      const peerPublicKey = params.senderPublicKey;
-      topic = await this.generateSharedKey(selfPublicKey, peerPublicKey);
-    }
     try {
+      if (isTypeOneEnvelope(params)) {
+        const selfPublicKey = params.receiverPublicKey;
+        const peerPublicKey = params.senderPublicKey;
+        topic = await this.generateSharedKey(selfPublicKey, peerPublicKey);
+      }
       const symKey = this.getSymKey(topic);
       const message = decrypt({ symKey, encoded, encoding: opts?.encoding });
       const payload = safeJsonParse(message);
       return payload;
     } catch (error) {
-      this.logger.error(
+      this.logger.warn(
         `Failed to decode message from topic: '${topic}', clientId: '${await this.getClientId()}'`,
       );
-      this.logger.error(error);
+      this.logger.warn(error instanceof Error ? error.message : String(error));
+      return undefined;
     }
   };
 

packages/core/src/controllers/history.ts

@@ -97,14 +97,18 @@ export class JsonRpcHistory extends IJsonRpcHistory {
     this.logger.debug(`Updating JSON-RPC response history record`);
     this.logger.trace({ type: "method", method: "update", response });
     if (!this.records.has(response.id)) return;
-    const record = await this.getRecord(response.id);
-    if (typeof record.response !== "undefined") return;
-    record.response = isJsonRpcError(response)
-      ? { error: response.error }
-      : { result: response.result };
-    this.records.set(record.id, record);
-    this.persist();
-    this.events.emit(HISTORY_EVENTS.updated, record);
+    try {
+      const record = await this.getRecord(response.id);
+      if (typeof record.response !== "undefined") return;
+      record.response = isJsonRpcError(response)
+        ? { error: response.error }
+        : { result: response.result };
+      this.records.set(record.id, record);
+      this.persist();
+      this.events.emit(HISTORY_EVENTS.updated, record);
+    } catch (error) {
+      this.logger.warn(`Failed to resolve history record ${response.id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
   };
 
   public get: IJsonRpcHistory["get"] = async (topic, id) => {

packages/sign-client/src/controllers/engine.ts

@@ -1987,6 +1987,11 @@ export class Engine extends IEngine {
         encoding: transportType === TRANSPORT_TYPES.link_mode ? BASE64URL : BASE64,
       });
 
+      if (!payload) {
+        this.client.logger.warn(`onRelayMessage() -> decode returned undefined for topic: ${topic}`);
+        return;
+      }
+
       if (isJsonRpcRequest(payload)) {
         this.client.core.history.set(topic, payload);
         await this.onRelayEventRequest({
@@ -2089,7 +2094,13 @@ export class Engine extends IEngine {
 
   private onRelayEventResponse: EnginePrivate["onRelayEventResponse"] = async (event) => {
     const { topic, payload, transportType } = event;
-    const record = await this.client.core.history.get(topic, payload.id);
+    let record;
+    try {
+      record = await this.client.core.history.get(topic, payload.id);
+    } catch (error) {
+      this.client.logger.warn(`onRelayEventResponse() -> history record not found for id ${payload.id}: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
     const resMethod = record.request.method as JsonRpcTypes.WcMethod;
 
     switch (resMethod) {