aunubaileys 1.0.17 → 1.0.19

package/README.md

@@ -64,6 +64,14 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🆕 What's new in 1.0.19 / Baru di 1.0.19
+
+- 🛟 **A failed retry request can no longer kill your bot** — the retry-receipt path after a decrypt failure runs fire-and-forget (by design), but its promise had no error handler at all: one failure inside it became an unhandled rejection, and Node's default policy terminates the whole process. It now routes to the standard error handler — logged, contained, and the bot keeps processing messages.
+
+### 🆕 What's new in 1.0.18 / Baru di 1.0.18
+
+- 🔁 **Retry receipts: the peer's own key bundle is finally used** — when a recipient device asks for a resend, its retry receipt often embeds that device's own current key bundle. Upstream ignored it and always re-fetched a bundle from the server (extra round trip, and JID→bundle mapping is fragile for LID participants). AunuBaileys now parses the bundle (new exported `parseRetryReceiptSession`, unit-verified) and injects it as the fresh session for the resend, skipping the server fetch for that resend. Receipts without a bundle behave exactly as before.
+
 ### 🆕 What's new in 1.0.17 / Baru di 1.0.17
 
 - 👥 **Group sender-key heal** — the 1.0.14 failure counter now covers group messages too: after 3 consecutive group decrypt failures from the same author in the same group, the stale sender-key record is deleted (new `signalRepository.deleteSenderKey`), so the next retry makes the author resend with a fresh distribution message and the group cipher rebuilds from scratch. One rotten sender-key record can no longer mute a group member forever.

package/WAProto/fix-imports.js

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync } from 'fs';
-import { argv, exit } from 'process';
+import { exit } from 'process';
 
 const filePath = './index.js';
 

package/lib/Socket/messages-recv.js

@@ -5,7 +5,7 @@ import Long from 'long';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT } from '../Defaults/index.js';
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
-import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
+import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, parseRetryReceiptSession, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
 import { sentMessageCacheFor } from '../Utils/sent-message-cache.js';
 import { areJidsSameUser, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidStatusBroadcast, isJidUser, isLidUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
@@ -481,8 +481,7 @@ export const makeMessagesRecvSocket = (config) => {
         const newValue = (msgRetryCache.get(key) || 0) + 1;
         msgRetryCache.set(key, newValue);
     };
-    const sendMessagesAgain = async (key, ids, retryNode) => {
-        // todo: implement a cache to store the last 256 sent messages (copy whatsmeow)
+    const sendMessagesAgain = async (key, ids, retryNode, sessionPreInjected = false) => {
         const msgs = await Promise.all(ids.map(async (id) => (await getMessage({ ...key, id })) ?? sentMessageCacheFor(config).get(key.remoteJid, id)));
         const remoteJid = key.remoteJid;
         const participant = key.participant || remoteJid;
@@ -490,7 +489,9 @@ export const makeMessagesRecvSocket = (config) => {
         // just re-send the message to everyone
         // prevents the first message decryption failure
         const sendToAll = !jidDecode(participant)?.device;
-        await assertSessions([participant], true);
+        if (!sessionPreInjected) {
+            await assertSessions([participant], true);
+        }
         if (isJidGroup(remoteJid)) {
             await authState.keys.set({ 'sender-key-memory': { [remoteJid]: null } });
         }
@@ -572,7 +573,24 @@ export const makeMessagesRecvSocket = (config) => {
                             if (key.fromMe) {
                                 try {
                                     logger.debug({ attrs, key }, 'recv retry request');
-                                    await sendMessagesAgain(key, ids, retryNode);
+                                    // AunuBaileys: when the retry receipt carries the
+                                    // requester's own key bundle, build the fresh
+                                    // session from THAT (authoritative for the exact
+                                    // device, no server round trip) and skip the
+                                    // force-fetch inside sendMessagesAgain.
+                                    let sessionPreInjected = false;
+                                    const bundleSession = parseRetryReceiptSession(node);
+                                    if (bundleSession && key.participant) {
+                                        try {
+                                            await signalRepository.injectE2ESession({ jid: key.participant, session: bundleSession });
+                                            sessionPreInjected = true;
+                                            logger.debug({ participant: key.participant }, 'aunu: injected E2E session from retry receipt bundle');
+                                        }
+                                        catch (injErr) {
+                                            logger.debug({ err: injErr }, 'aunu: retry receipt bundle injection failed; falling back to server fetch');
+                                        }
+                                    }
+                                    await sendMessagesAgain(key, ids, retryNode, sessionPreInjected);
                                 }
                                 catch (error) {
                                     logger.error({ key, ids, trace: error.stack }, 'error in sending message again');
@@ -711,7 +729,13 @@ export const makeMessagesRecvSocket = (config) => {
                             else {
                                 logger.debug({ node }, 'connection closed, ignoring retry req');
                             }
-                        });
+                        }).catch(err => onUnexpectedError(err, 'sending retry request'));
+                        // AunuBaileys: this mutex call is deliberately fire-and-forget
+                        // (it must not block message processing), but until now its
+                        // rejection was UNHANDLED — a failed retry request (socket
+                        // died mid-flight, pre-key fetch error) crashed the whole
+                        // process under Node's default unhandled-rejection policy.
+                        // It is now routed to the standard error handler instead.
                     }
                     else {
                         if (author) {

package/lib/Utils/signal.d.ts

@@ -16,6 +16,8 @@ export declare const generateOrGetPreKeys: (creds: AuthenticationCreds, range: n
 export declare const xmppSignedPreKey: (key: SignedKeyPair) => BinaryNode;
 export declare const xmppPreKey: (pair: KeyPair, id: number) => BinaryNode;
 export declare const parseAndInjectE2ESessions: (node: BinaryNode, repository: SignalRepository) => Promise<void>;
+/** AunuBaileys: session parsed from a retry receipt's embedded key bundle, or undefined when absent. */
+export declare const parseRetryReceiptSession: (node: BinaryNode) => { registrationId: number; identityKey: Buffer; signedPreKey?: { keyId: number; publicKey: Buffer; signature?: Buffer }; preKey?: { keyId: number; publicKey: Buffer } } | undefined;
 export declare const extractDeviceJids: (result: USyncQueryResultList[], myJid: string, excludeZeroDevices: boolean) => JidWithDevice[];
 /**
  * get the next N keys for upload or processing

package/lib/Utils/signal.js

@@ -55,6 +55,37 @@ export const xmppPreKey = (pair, id) => ({
         { tag: 'value', attrs: {}, content: pair.public }
     ]
 });
+/** AunuBaileys: parse the E2E key bundle embedded in a retry receipt.
+ * When a recipient device asks us to resend, its receipt often carries the
+ * device's OWN current key bundle (<keys> + <registration>) — the device
+ * itself stating "build your session to me from THIS". Upstream ignores it
+ * and re-fetches a bundle from the server instead; consuming the receipt's
+ * bundle skips that round trip and, more importantly, is authoritative for
+ * the exact requesting device (server lookups by JID are fragile for LID
+ * participants). Returns undefined when the receipt carries no bundle. */
+export const parseRetryReceiptSession = (node) => {
+    const keysNode = getBinaryNodeChild(node, 'keys');
+    if (!keysNode) {
+        return undefined;
+    }
+    const identity = getBinaryNodeChildBuffer(keysNode, 'identity');
+    if (!identity) {
+        return undefined;
+    }
+    const extractKey = (key) => key
+        ? {
+            keyId: getBinaryNodeChildUInt(key, 'id', 3),
+            publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
+            signature: getBinaryNodeChildBuffer(key, 'signature')
+        }
+        : undefined;
+    return {
+        registrationId: getBinaryNodeChildUInt(node, 'registration', 4),
+        identityKey: generateSignalPubKey(identity),
+        signedPreKey: extractKey(getBinaryNodeChild(keysNode, 'skey')),
+        preKey: extractKey(getBinaryNodeChild(keysNode, 'key'))
+    };
+};
 export const parseAndInjectE2ESessions = async (node, repository) => {
     const extractKey = (key) => key
         ? {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "AunuBaileys \u2014 a WhatsApp Web API for bots that never sleep. Full upstream power with the beloved in-memory store restored and pairing that just works. Forged by AunuCore.",
   "keywords": [
     "whatsapp",