@aunucore/baileys 1.0.78 → 1.0.80

package/lib/Socket/chats.js

@@ -189,7 +189,15 @@ export const makeChatsSocket = (config) => {
         if (!jid) {
             throw new Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update');
         }
-        if (jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id)) {
+        // AunuBaileys (1.0.79, HB-125): creds.me is undefined until
+        // pairing completes (and again after a pairing rollback) —
+        // the bare deref below threw a raw TypeError for a host
+        // calling too early. Fail like the guarded send paths.
+        const meId = authState.creds.me?.id;
+        if (!meId) {
+            throw new Boom('Not authenticated');
+        }
+        if (jidNormalizedUser(jid) !== jidNormalizedUser(meId)) {
             targetJid = jidNormalizedUser(jid); // in case it is someone other than us
         }
         else {
@@ -219,7 +227,13 @@ export const makeChatsSocket = (config) => {
         if (!jid) {
             throw new Boom('Illegal no-jid profile update. Please specify either your ID or the ID of the chat you wish to update');
         }
-        if (jidNormalizedUser(jid) !== jidNormalizedUser(authState.creds.me.id)) {
+        // AunuBaileys (1.0.79, HB-125): same bare creds.me.id deref
+        // as updateProfilePicture — same guard.
+        const meId = authState.creds.me?.id;
+        if (!meId) {
+            throw new Boom('Not authenticated');
+        }
+        if (jidNormalizedUser(jid) !== jidNormalizedUser(meId)) {
             targetJid = jidNormalizedUser(jid); // in case it is someone other than us
         }
         else {
@@ -529,6 +543,13 @@ export const makeChatsSocket = (config) => {
     };
     const sendPresenceUpdate = async (type, toJid) => {
         const me = authState.creds.me;
+        // AunuBaileys (1.0.79, HB-125): me is undefined until pairing
+        // completes; both branches below deref it bare (me.name in
+        // this one, me.lid/me.id in the chatstate branch) and threw
+        // a raw TypeError for an early host call.
+        if (!me?.id) {
+            throw new Boom('Not authenticated');
+        }
         if (type === 'available' || type === 'unavailable') {
             if (!me.name) {
                 logger.warn('no name present, ignoring presence update request...');
@@ -851,7 +872,12 @@ export const makeChatsSocket = (config) => {
         }
         ev.emit('messages.upsert', { messages: [msg], type });
         if (!!msg.pushName) {
-            let jid = msg.key.fromMe ? authState.creds.me.id : msg.key.participant || msg.key.remoteJid;
+            // AunuBaileys (1.0.79, HB-125): me?.id — a fromMe message
+            // with a pushName processed before pairing completes
+            // threw a raw TypeError here; jidNormalizedUser maps an
+            // undefined jid to '' and the fromMe path does not use
+            // the computed jid for anything but normalisation.
+            let jid = msg.key.fromMe ? authState.creds.me?.id : msg.key.participant || msg.key.remoteJid;
             jid = jidNormalizedUser(jid);
             if (!msg.key.fromMe) {
                 ev.emit('contacts.update', [{ id: jid, notify: msg.pushName, verifiedName: msg.verifiedBizName }]);

package/lib/Socket/communities.js

@@ -246,6 +246,11 @@ export const makeCommunitiesSocket = (config) => {
          */
         communityAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
             key = typeof key === 'string' ? { remoteJid: key } : key;
+            // AunuBaileys (1.0.79, HB-125): same bare creds.me.id
+            // deref as groupAcceptInviteV4 — same guard.
+            if (!authState.creds.me?.id) {
+                throw new Boom('Not authenticated');
+            }
             const results = await communityQuery(inviteMessage.groupJid, 'set', [
                 {
                     tag: 'accept',

package/lib/Socket/groups.js

@@ -207,6 +207,13 @@ export const makeGroupsSocket = (config) => {
          */
         groupAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
             key = typeof key === 'string' ? { remoteJid: key } : key;
+            // AunuBaileys (1.0.79, HB-125): creds.me.id is
+            // dereferenced for the stub message below (and inside
+            // processMessage); before pairing completes it threw a
+            // raw TypeError. Fail before any network work.
+            if (!authState.creds.me?.id) {
+                throw new Boom('Not authenticated');
+            }
             const results = await groupQuery(inviteMessage.groupJid, 'set', [
                 {
                     tag: 'accept',

package/lib/Socket/index.js

@@ -25,6 +25,32 @@ const makeWASocket = (config) => {
         ...DEFAULT_CONNECTION_CONFIG.transactionOpts,
         ...(config?.transactionOpts ?? {})
     };
+    // AunuBaileys (1.0.80, HB-139 + HB-174 + addendum HB-139): the
+    // numeric connection config was spread raw above — an explicit
+    // undefined/NaN from the host (classically `Number(env.X)` of an
+    // unset variable) silently replaced the defaults, and every
+    // failure mode is silent: promiseTimeout(NaN) never settles (a
+    // half-open socket hangs forever), a NaN/0/negative
+    // keepAliveIntervalMs collapses setInterval to 1 ms (~850 ping
+    // IQs per second, and the dead-connection watchdog compares
+    // against NaN so it never fires), and a NaN/Infinity
+    // maxMsgRetryCount breaks both retry gates in opposite
+    // directions at once (retry receipts never capped, resends
+    // never sent). Sanitise once, here at the boundary: timeouts
+    // and intervals must be positive finite (else the documented
+    // default), the retry count must be finite (else the default),
+    // and qrTimeout — which has no Defaults entry (genPairQR falls
+    // back with `|| 60000` / `|| 20000`) — must be positive finite
+    // or absent (a negative value is truthy and would expire every
+    // QR instantly).
+    const positiveFiniteOr = (value, fallback) => (Number.isFinite(value) && value > 0 ? value : fallback);
+    newConfig.connectTimeoutMs = positiveFiniteOr(newConfig.connectTimeoutMs, DEFAULT_CONNECTION_CONFIG.connectTimeoutMs);
+    newConfig.defaultQueryTimeoutMs = positiveFiniteOr(newConfig.defaultQueryTimeoutMs, DEFAULT_CONNECTION_CONFIG.defaultQueryTimeoutMs);
+    newConfig.keepAliveIntervalMs = positiveFiniteOr(newConfig.keepAliveIntervalMs, DEFAULT_CONNECTION_CONFIG.keepAliveIntervalMs);
+    newConfig.maxMsgRetryCount = Number.isFinite(newConfig.maxMsgRetryCount) ? newConfig.maxMsgRetryCount : DEFAULT_CONNECTION_CONFIG.maxMsgRetryCount;
+    if (newConfig.qrTimeout !== undefined && !(Number.isFinite(newConfig.qrTimeout) && newConfig.qrTimeout > 0)) {
+        newConfig.qrTimeout = undefined;
+    }
     // If the user hasn't provided their own history sync function,
     // let's create a default one that respects the syncFullHistory flag.
     if (config.shouldSyncHistoryMessage === undefined) {

package/lib/Socket/messages-recv.js

@@ -12,6 +12,10 @@ import { createOfflineNodeQueue } from '../Utils/offline-queue.js';
 import { areJidsSameUser, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidStatusBroadcast, isJidUser, isLidUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { extractGroupMetadata } from './groups.js';
 import { makeMessagesSocket } from './messages-send.js';
+/** AunuBaileys (1.0.79, HB-201): the HB-98 key-material test — key
+ * material is a Buffer (or a base64 string in a hand-edited creds
+ * file); anything else is a wrong-typed corrupt value. */
+const isKeyMaterial = (value) => Buffer.isBuffer(value) || typeof value === 'string';
 /** AunuBaileys: classify an <unavailable/> placeholder — 'bot' when a
  * <bot/> child rides along, 'hosted' when the node says so, otherwise
  * the unavailable type attribute (e.g. 'view_once'). */
@@ -82,6 +86,13 @@ export const makeMessagesRecvSocket = (config) => {
     // AunuBaileys: terima panggilan masuk (node kontrol <accept>) — pasangan
     // rejectCall bawaan; media VOIP-nya sendiri di luar cakupan protokol chat.
     const acceptCall = async (callId, callFrom) => {
+        // AunuBaileys (1.0.79, HB-172): creds.me.id was dereferenced
+        // bare in the stanza literal — a host auto-accepting a call
+        // before pairing completes got a raw TypeError instead of
+        // the guarded failure the neighbouring helpers give.
+        if (!authState.creds.me?.id) {
+            throw new Boom('Not authenticated');
+        }
         await query(buildCallControlStanza({
             from: authState.creds.me.id,
             to: callFrom,
@@ -92,6 +103,11 @@ export const makeMessagesRecvSocket = (config) => {
     };
     // AunuBaileys: akhiri panggilan yang sedang berjalan (<terminate>).
     const terminateCall = async (callId, callFrom, reason = 'user-terminated') => {
+        // AunuBaileys (1.0.79, HB-172): same bare creds.me.id deref
+        // as acceptCall — guard first.
+        if (!authState.creds.me?.id) {
+            throw new Boom('Not authenticated');
+        }
         await query(buildCallControlStanza({
             from: authState.creds.me.id,
             to: callFrom,
@@ -102,6 +118,11 @@ export const makeMessagesRecvSocket = (config) => {
         }));
     };
     const rejectCall = async (callId, callFrom) => {
+        // AunuBaileys (1.0.79, HB-172): same bare creds.me.id deref
+        // as acceptCall — guard first.
+        if (!authState.creds.me?.id) {
+            throw new Boom('Not authenticated');
+        }
         const stanza = {
             tag: 'call',
             attrs: {
@@ -144,9 +165,28 @@ export const makeMessagesRecvSocket = (config) => {
             logger.debug({ retryCount, msgId }, 'reached retry limit');
             return;
         }
+        const { account, signedPreKey, signedIdentityKey: identityKey } = authState.creds;
+        // AunuBaileys (1.0.79, HB-201 + addendum HB-80): the receipt
+        // built below always embeds creds.registrationId, and from
+        // the second retry on it also embeds the identity and
+        // signed-pre-key material — all of it dereferenced bare
+        // inside the transaction callback. With a partial creds
+        // restore those derefs threw TypeError AFTER the retry
+        // counter above had already been consumed: the receipt was
+        // never sent, the counter was burned, and every later retry
+        // failed at the same spot until the cap left the message a
+        // stub forever. (A missing registrationId was worse — it
+        // silently encoded as 00000000.) Validate BEFORE the
+        // increment and fail descriptively: the counter is only
+        // spent on a receipt that can actually be built.
+        if (!Number.isFinite(authState.creds.registrationId)) {
+            throw new Error('AunuBaileys: creds.registrationId is missing or invalid — cannot send a retry receipt; restore a full backup or pair again');
+        }
+        if ((retryCount >= 1 || forceIncludeKeys) && (!isKeyMaterial(identityKey?.public) || !isKeyMaterial(signedPreKey?.keyPair?.public) || !isKeyMaterial(signedPreKey?.signature) || typeof signedPreKey?.keyId === 'undefined')) {
+            throw new Error('AunuBaileys: creds.signedIdentityKey / creds.signedPreKey are missing or incomplete — cannot include keys in the retry receipt; restore a full backup or pair again');
+        }
         retryCount += 1;
         msgRetryCache.set(key, retryCount);
-        const { account, signedPreKey, signedIdentityKey: identityKey } = authState.creds;
         if (retryCount === 1) {
             // AunuBaileys (1.0.70): requestPlaceholderResend waits 5s
             // for the message to arrive by other means — awaiting it
@@ -206,7 +246,7 @@ export const makeMessagesRecvSocket = (config) => {
                     attrs: {},
                     content: [
                         { tag: 'type', attrs: {}, content: Buffer.from(KEY_BUNDLE_TYPE) },
-                        { tag: 'identity', attrs: {}, content: identityKey.public },
+                        { tag: 'identity', attrs: {}, content: keyMaterialToBuffer(identityKey.public) },
                         xmppPreKey(key, +keyId),
                         xmppSignedPreKey(signedPreKey),
                         { tag: 'device-identity', attrs: {}, content: deviceIdentity }
@@ -1042,7 +1082,14 @@ export const makeMessagesRecvSocket = (config) => {
                         // vanished silently if the retry also failed
                         // (HB-90; upstream v7 falls through to the
                         // upsert for exactly this reason).
-                        cleanMessage(msg, authState.creds.me.id);
+                        // AunuBaileys (1.0.79, HB-131): me?.id — in
+                        // the pre-success window creds.me is still
+                        // undefined and the bare deref threw AFTER the
+                        // retry receipt had already been fired: the
+                        // stub was never upserted and the stanza was
+                        // NACKed 500 (delivered + failed). cleanMessage
+                        // tolerates an undefined meId.
+                        cleanMessage(msg, authState.creds.me?.id);
                         await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
                     }
                     else {
@@ -1080,7 +1127,12 @@ export const makeMessagesRecvSocket = (config) => {
                             await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync');
                         }
                     }
-                    cleanMessage(msg, authState.creds.me.id);
+                    // AunuBaileys (1.0.79, HB-131): me?.id — the
+                    // bare deref threw here AFTER sendReceipt had
+                    // already gone out, NACKing a delivered message
+                    // 500 and bursting redeliveries until CB:success
+                    // landed. cleanMessage tolerates undefined.
+                    cleanMessage(msg, authState.creds.me?.id);
                     await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
                 })
             ]);

package/lib/Utils/auth-utils.js

@@ -96,8 +96,16 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
     // commit attempt. Fall back per-field to the Defaults values, and
     // clamp retries to at least 1 so an explicit 0 means exactly one
     // attempt, matching host intent.
-    const commitRetries = Math.max(1, maxCommitRetries ?? 10);
-    const commitDelayMs = delayBetweenTriesMs ?? 3000;
+    // AunuBaileys (1.0.79, addendum HB-104): the ?? fallback lets NaN
+    // through (Math.max(1, NaN) is NaN — the commit loop below then
+    // runs ZERO times and every mutating transaction throws without
+    // a single attempt) and lets Infinity through (the loop never
+    // ends on a failing store and wedges the transaction mutex —
+    // the whole key store deadlocks until restart). Sanitise at the
+    // boundary: retries must be a finite integer, clamped to 1..10;
+    // a non-finite or negative delay falls back to the default.
+    const commitRetries = Number.isFinite(maxCommitRetries) ? Math.min(10, Math.max(1, Math.floor(maxCommitRetries))) : 10;
+    const commitDelayMs = Number.isFinite(delayBetweenTriesMs) && delayBetweenTriesMs >= 0 ? delayBetweenTriesMs : 3000;
     // number of queries made to the DB during the transaction
     // only there for logging purposes
     let dbQueriesInTransaction = 0;
@@ -114,6 +122,20 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
     const transactionContext = new AsyncLocalStorage();
     const runTransaction = async (work) => {
         let result;
+        // AunuBaileys (1.0.79, HB-236): a nested transaction joins the
+        // running one and SHARES its cache/mutations — snapshot both
+        // when entering a nested frame. If the nested work throws,
+        // the snapshot is restored before the error propagates (see
+        // the catch below): without it, an outer frame that catches
+        // the throw would commit the inner frame's partial writes as
+        // if nothing had failed — the only "rollback" was a throw
+        // escaping the OUTERMOST frame.
+        const snapshot = transactionsInProgress > 0
+            ? {
+                cache: Object.fromEntries(Object.entries(transactionCache).map(([type, dict]) => [type, { ...dict }])),
+                mutations: Object.fromEntries(Object.entries(mutations).map(([type, dict]) => [type, { ...dict }]))
+            }
+            : undefined;
         transactionsInProgress += 1;
         if (transactionsInProgress === 1) {
             logger.trace('entering transaction');
@@ -159,6 +181,17 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
                 }
             }
         }
+        catch (error) {
+            // AunuBaileys (1.0.79, HB-236): roll a failed NESTED frame
+            // back to its entry snapshot (see above); the outermost
+            // frame needs no restore — the finally below resets the
+            // shared state outright.
+            if (snapshot) {
+                transactionCache = snapshot.cache;
+                mutations = snapshot.mutations;
+            }
+            throw error;
+        }
         finally {
             transactionsInProgress -= 1;
             if (transactionsInProgress === 0) {
@@ -173,7 +206,14 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
         get: async (type, ids) => {
             if (isInTransaction()) {
                 const dict = transactionCache[type];
-                const idsRequiringFetch = dict ? ids.filter(item => typeof dict[item] === 'undefined') : ids;
+                // AunuBaileys (1.0.79, HB-233): cache PRESENCE — not
+                // the value — decides whether a fetch is needed. A
+                // key explicitly set to undefined in this transaction
+                // is a deletion marker; the typeof test could not
+                // tell it from "never fetched", so get re-read the
+                // stale persisted value and resurrected a record the
+                // transaction itself had just deleted.
+                const idsRequiringFetch = dict ? ids.filter(item => !Object.prototype.hasOwnProperty.call(dict, item)) : ids;
                 // only fetch if there are any items to fetch
                 if (idsRequiringFetch.length) {
                     dbQueriesInTransaction += 1;

package/lib/Utils/bounded-cache.js

@@ -13,7 +13,15 @@
  * the receive path uses.
  */
 export const makeBoundedTTLCache = ({ ttlSeconds = 3600, maxEntries = 1000 } = {}) => {
-    const ttlMs = Math.max(1, ttlSeconds * 1000);
+    // AunuBaileys (1.0.80, HB-145): NaN/Infinity config defeated
+    // both bounds — `size > NaN` is always false (no eviction,
+    // ever) and a NaN ttlMs made expiresAt NaN, which never
+    // compares <= now, so entries lived forever. Sanitise at the
+    // boundary: finite values keep their exact meaning (counts
+    // are floored and clamped at 0), non-finite values fall back
+    // to the documented defaults (3600 s / 1000 entries).
+    const ttlMs = Number.isFinite(ttlSeconds) ? Math.max(1, ttlSeconds * 1000) : 3600 * 1000;
+    const limit = Number.isFinite(maxEntries) ? Math.max(0, Math.floor(maxEntries)) : 1000;
     const map = new Map();
     return {
         get(key) {
@@ -28,11 +36,20 @@ export const makeBoundedTTLCache = ({ ttlSeconds = 3600, maxEntries = 1000 } = {
         },
         set(key, value) {
             map.set(key, { value, expiresAt: Date.now() + ttlMs });
-            while (map.size > maxEntries) {
-                const oldest = map.keys().next().value;
-                if (oldest === undefined)
+            // AunuBaileys (1.0.80, HB-226): the old guard broke out
+            // when the oldest KEY was `undefined` — but a Map can
+            // legitimately HOLD undefined as a key (two in-tree
+            // callers can produce one: a call offer without a
+            // call-id, a placeholder resend without a message id),
+            // and one such entry silently disabled the ceiling
+            // until it expired. The iterator's `done` flag is the
+            // real "map is empty" signal; deleting an undefined
+            // key is perfectly safe.
+            while (map.size > limit) {
+                const oldest = map.keys().next();
+                if (oldest.done)
                     break;
-                map.delete(oldest);
+                map.delete(oldest.value);
             }
         },
         del(key) {

package/lib/Utils/lid-store.js

@@ -15,7 +15,16 @@ import { jidNormalizedUser, isJidUser, isLidUser } from '../WABinary/jid-utils.j
  * fed manually via `learnFromMessage` / `addPair`.
  */
 export const makeLIDStore = (options = {}) => {
-    const maxEntries = options.maxEntries ?? 5000;
+    // AunuBaileys (1.0.80, HB-190 + addendum HB-145): `?? 5000`
+    // let NaN through (the eviction comparison `size > NaN` is
+    // always false — the store grew without bound) and let
+    // negatives through (evictIfNeeded's while loop then spun
+    // forever on an empty map: `size > -1` stays true while
+    // delete(undefined) is a no-op — a wedged process, no error).
+    // Sanitise at the boundary: finite values are floored and
+    // clamped at 0 (0 = store nothing, which terminates),
+    // non-finite values fall back to the default 5000.
+    const maxEntries = Number.isFinite(options.maxEntries) ? Math.max(0, Math.floor(options.maxEntries)) : 5000;
     // AunuBaileys (1.0.71): optional listener fired when a genuinely
     // NEW or changed PN<->LID pair is learned (re-learning an already
     // known pair does not fire). The socket wires it to 'lid-mapping.update'.
@@ -29,7 +38,17 @@ export const makeLIDStore = (options = {}) => {
     };
     const evictIfNeeded = () => {
         while (pnToLid.size > maxEntries) {
-            const oldestPn = pnToLid.keys().next().value;
+            // AunuBaileys (1.0.80, HB-190 defence in depth): with a
+            // sanitised maxEntries (>= 0) this loop always
+            // terminates, but never trust a loop whose only exit is
+            // a size comparison — bail out if the map is somehow
+            // already empty (the iterator's `done`, not the key's
+            // value, is the empty signal).
+            const oldest = pnToLid.keys().next();
+            if (oldest.done) {
+                break;
+            }
+            const oldestPn = oldest.value;
             const lid = pnToLid.get(oldestPn);
             pnToLid.delete(oldestPn);
             if (lid) {

package/lib/Utils/noise-handler.js

@@ -2,7 +2,7 @@ import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { NOISE_MODE, WA_CERT_DETAILS } from '../Defaults/index.js';
 import { decodeBinaryNode } from '../WABinary/index.js';
-import { aesDecryptGCM, aesEncryptGCM, Curve, hkdf, sha256 } from './crypto.js';
+import { aesDecryptGCM, aesEncryptGCM, Curve, hkdf, keyMaterialToBuffer, sha256 } from './crypto.js';
 const generateIV = (counter) => {
     const iv = new ArrayBuffer(12);
     new DataView(iv).setUint32(8, counter);
@@ -94,6 +94,30 @@ export const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publi
             if (!noiseKey?.public || !noiseKey?.private) {
                 throw new Error('AunuBaileys: creds.noiseKey is missing or incomplete — the auth state is incomplete or corrupt; restore a full backup or pair again');
             }
+            // AunuBaileys (1.0.79, addendum HB-102): the truthiness
+            // check above lets a WRONG-TYPED noiseKey through — a
+            // number/object died as a bare TypeError inside
+            // aesEncryptGCM, and a base64 string was silently
+            // encrypted as UTF-8 bytes, so the server received a
+            // garbage public key and the handshake failed remotely
+            // with no local diagnosis. Normalise with
+            // keyMaterialToBuffer (the HB-157 house rule) and
+            // require real 32-byte keys.
+            const noisePublic = keyMaterialToBuffer(noiseKey.public);
+            const noisePrivate = keyMaterialToBuffer(noiseKey.private);
+            if (!Buffer.isBuffer(noisePublic) || noisePublic.length !== 32 || !Buffer.isBuffer(noisePrivate) || noisePrivate.length !== 32) {
+                throw new Error('AunuBaileys: creds.noiseKey is malformed (public/private must be 32-byte keys) — the auth state is incomplete or corrupt; restore a full backup or pair again');
+            }
+            // AunuBaileys (1.0.79, HB-238): the first handshake frame
+            // is plaintext, so an intercepting middlebox (ISP
+            // intercept page, broken proxy) can deliver a decoded
+            // handshake with NO serverHello at all — the derefs
+            // below then threw a bare TypeError and the host
+            // reconnect-looped on it. Fail descriptively, in the
+            // HB-80/HB-102 style.
+            if (!serverHello || typeof serverHello !== 'object' || !(serverHello.ephemeral instanceof Uint8Array) || !(serverHello.static instanceof Uint8Array) || !(serverHello.payload instanceof Uint8Array)) {
+                throw new Error('AunuBaileys: the server handshake is malformed — serverHello or its encrypted parts are missing (the connection may have been intercepted); reconnecting will retry');
+            }
             authenticate(serverHello.ephemeral);
             await mixIntoKey(Curve.sharedKey(privateKey, serverHello.ephemeral));
             const decStaticContent = decrypt(serverHello.static);
@@ -104,8 +128,8 @@ export const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publi
             if (issuerSerial !== WA_CERT_DETAILS.SERIAL) {
                 throw new Boom('certification match failed', { statusCode: 400 });
             }
-            const keyEnc = encrypt(noiseKey.public);
-            await mixIntoKey(Curve.sharedKey(noiseKey.private, serverHello.ephemeral));
+            const keyEnc = encrypt(noisePublic);
+            await mixIntoKey(Curve.sharedKey(noisePrivate, serverHello.ephemeral));
             return keyEnc;
         },
         encodeFrame: (data) => {

package/lib/Utils/process-message.js

@@ -100,7 +100,13 @@ export function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsg
     }
 }
 const processMessage = async (message, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, keyStore, logger, options }) => {
-    const meId = creds.me.id;
+    // AunuBaileys (1.0.79, HB-131): creds.me is undefined until
+    // pairing completes; the bare deref threw a TypeError for any
+    // message/notification processed in that window (reached via
+    // upsertMessage, which does not pass cleanMessage first). Every
+    // consumer of meId below (isRealMessage, areJidsSameUser,
+    // jidNormalizedUser) already tolerates undefined.
+    const meId = creds.me?.id;
     const { accountSettings } = creds;
     const chat = { id: jidNormalizedUser(getChatId(message.key)) };
     const isRealMsg = isRealMessage(message, meId);

package/lib/Utils/sent-message-cache.js

@@ -15,6 +15,14 @@
  * `sentMessagesCacheSize: 0` in the socket config to disable.
  */
 export const makeSentMessageCache = (maxEntries = 256, resolveAlternateJid) => {
+    // AunuBaileys (1.0.80, HB-145): a NaN cap (host config from an
+    // unset env var — sentMessageCacheFor's typeof check passes NaN
+    // straight through) made `cache.size > NaN` false forever, so
+    // the cache grew without bound; Infinity did the same.
+    // Sanitise at the boundary: finite values are floored and
+    // clamped at 0 (0 keeps its documented meaning — the cache is
+    // disabled), non-finite values fall back to the default 256.
+    const limit = Number.isFinite(maxEntries) ? Math.max(0, Math.floor(maxEntries)) : 256;
     const cache = new Map();
     const keyOf = (remoteJid, id) => `${remoteJid}:${id}`;
     let altResolver = typeof resolveAlternateJid === 'function' ? resolveAlternateJid : undefined;
@@ -30,13 +38,13 @@ export const makeSentMessageCache = (maxEntries = 256, resolveAlternateJid) => {
             }
         },
         add: (remoteJid, id, message) => {
-            if (!remoteJid || !id || !message || maxEntries <= 0) {
+            if (!remoteJid || !id || !message || limit <= 0) {
                 return;
             }
             const key = keyOf(remoteJid, id);
             cache.delete(key);
             cache.set(key, message);
-            while (cache.size > maxEntries) {
+            while (cache.size > limit) {
                 cache.delete(cache.keys().next().value);
             }
         },

package/lib/Utils/signal.js

@@ -35,6 +35,19 @@ export const generateOrGetPreKeys = (creds, range) => {
         throw new Error('AunuBaileys: creds.nextPreKeyId / creds.firstUnuploadedPreKeyId are missing — the auth state is incomplete or corrupt; restore a full backup or pair again');
     }
     const avaliable = creds.nextPreKeyId - creds.firstUnuploadedPreKeyId;
+    // AunuBaileys (1.0.80, HB-140 + HB-225): finite-but-INVERTED
+    // counters (firstUnuploadedPreKeyId > nextPreKeyId — hand-edited
+    // or partially restored creds) made `remaining` exceed `range`
+    // by the size of the gap, so the loop below generated keys for
+    // the GAP, not the request: gap 50k ≈ 5 s and +48 MB, gap 200k
+    // ≈ 21 s and +238 MB, and a ~2^31 gap would freeze the process
+    // outright — synchronously, inside the keys transaction, at
+    // every login. Same class as HB-84 above (corrupt counters),
+    // same answer: refuse descriptively. With consistent counters
+    // `remaining` can never exceed `range` by construction.
+    if (avaliable < 0) {
+        throw new Error('AunuBaileys: creds pre-key counters are inverted (firstUnuploadedPreKeyId > nextPreKeyId) — the auth state is corrupt; restore a full backup or pair again');
+    }
     const remaining = range - avaliable;
     const lastPreKeyId = creds.nextPreKeyId + remaining - 1;
     const newPreKeys = {};
@@ -231,6 +244,12 @@ export const getNextPreKeysNode = async (state, count) => {
     if (!isKeyMaterial(creds.signedIdentityKey?.public) || !isKeyMaterial(creds.signedPreKey?.keyPair?.public) || !isKeyMaterial(creds.signedPreKey?.signature) || typeof creds.signedPreKey?.keyId === 'undefined') {
         throw new Error('AunuBaileys: creds.signedIdentityKey / creds.signedPreKey are missing or incomplete — the auth state is incomplete or corrupt; restore a full backup or pair again');
     }
+    // AunuBaileys (1.0.79, addendum HB-80): same gap as
+    // generateRegistrationNode — a missing registrationId silently
+    // became registration 00000000 in the node below.
+    if (!Number.isFinite(creds.registrationId)) {
+        throw new Error('AunuBaileys: creds.registrationId is missing or invalid — the auth state is incomplete or corrupt; restore a full backup or pair again');
+    }
     const { update, preKeys } = await getNextPreKeys(state, count);
     const node = {
         tag: 'iq',

package/lib/Utils/use-multi-file-auth-state.js

@@ -36,6 +36,21 @@ const getFileLock = (path) => {
  * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
  * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
  * */
+// AunuBaileys (1.0.79, HB-151): the shape a complete creds state
+// must have at load. Key material follows the HB-98 test (a Buffer,
+// or a base64 string in a hand-edited file); the ids must be finite
+// numbers. Anything else is a partial/corrupt restore, not a state
+// the socket can run on.
+const isCredsKeyPair = (kp) => !!kp && typeof kp === 'object' && (Buffer.isBuffer(kp.private) || typeof kp.private === 'string') && (Buffer.isBuffer(kp.public) || typeof kp.public === 'string');
+const isValidCredsShape = (creds) => !!creds &&
+    typeof creds === 'object' &&
+    !Array.isArray(creds) &&
+    isCredsKeyPair(creds.noiseKey) &&
+    isCredsKeyPair(creds.signedIdentityKey) &&
+    isCredsKeyPair(creds.signedPreKey?.keyPair) &&
+    (Buffer.isBuffer(creds.signedPreKey?.signature) || typeof creds.signedPreKey?.signature === 'string') &&
+    Number.isFinite(creds.signedPreKey?.keyId) &&
+    Number.isFinite(creds.registrationId);
 export const useMultiFileAuthState = async (folder, logger) => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const writeData = async (data, file) => {
@@ -118,7 +133,21 @@ export const useMultiFileAuthState = async (folder, logger) => {
         await mkdir(folder, { recursive: true });
     }
     const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
-    const creds = (await readData('creds.json')) || initAuthCreds();
+    const storedCreds = await readData('creds.json');
+    // AunuBaileys (1.0.79, HB-151): a creds.json that parses to {} /
+    // a partial object / a non-object used to be accepted as a
+    // complete auth state (it is truthy), and every downstream
+    // consumer then failed in its own way — reconnect loops with
+    // misleading TypeErrors, indistinguishable from a lib bug.
+    // Validate at this one load choke point; a present-but-invalid
+    // creds is discarded loudly, exactly like a corrupt-JSON file
+    // since 1.0.63.
+    const creds = isValidCredsShape(storedCreds) ? storedCreds : (() => {
+        if (storedCreds) {
+            logger?.error({ file: 'creds.json' }, 'aunu: creds.json does not have the shape of a complete auth state — discarding it and starting fresh; restore a full backup or pair again');
+        }
+        return initAuthCreds();
+    })();
     let credsWriteInFlight = null;
     let credsWriteQueued = false;
     return {

package/lib/Utils/validate-connection.js

@@ -60,7 +60,21 @@ export const generateLoginNode = (userJid, config) => {
     if (!decoded) {
         throw new Boom(`Invalid own JID for login node: ${userJid}`, { statusCode: 400 });
     }
-    const { user, device } = decoded;
+    const { user, device, server } = decoded;
+    // AunuBaileys (1.0.79, HB-234): the HB-43 guard above only
+    // checks that the JID decodes — a non-numeric user
+    // ('abc@s.whatsapp.net') was then silently coerced by +user to
+    // username 0 (or clamped to int64-max on a 26-digit overflow)
+    // and the login node went out carrying a WRONG identity,
+    // looping on server rejects. Validate the parts: the user must
+    // be all digits, non-zero and within int64 range; the server
+    // must be the user server; and a present device must be a
+    // finite number (jidDecode's +device turns 'xx' into NaN,
+    // which protobuf then silently encoded as 0).
+    const userValue = /^\d+$/.test(user) ? BigInt(user) : 0n;
+    if (userValue <= 0n || userValue > 9223372036854775807n || server !== 's.whatsapp.net' || (typeof device !== 'undefined' && !Number.isFinite(device))) {
+        throw new Boom(`Invalid own JID for login node: ${userJid}`, { statusCode: 400 });
+    }
     const payload = {
         ...getClientPayload(config),
         passive: false,
@@ -83,6 +97,14 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
     if (!isKeyMaterial(signedIdentityKey?.public) || !isKeyMaterial(signedPreKey?.keyPair?.public) || typeof signedPreKey?.keyId === 'undefined' || !isKeyMaterial(signedPreKey?.signature)) {
         throw new Error('AunuBaileys: creds.signedIdentityKey / creds.signedPreKey are missing or incomplete — the auth state is incomplete or corrupt; restore a full backup or pair again');
     }
+    // AunuBaileys (1.0.79, addendum HB-80): registrationId was NOT
+    // part of the guard — encodeBigEndian(undefined) does not
+    // throw, it silently produces eRegid 00000000, so a partial
+    // creds restore registered with a bogus registration id and
+    // no local signal at all.
+    if (!Number.isFinite(registrationId)) {
+        throw new Error('AunuBaileys: creds.registrationId is missing or invalid — the auth state is incomplete or corrupt; restore a full backup or pair again');
+    }
     // the app version needs to be md5 hashed
     // and passed in
     const safeVersion = Array.isArray(config.version) && config.version.length ? config.version : [2, 3000, 1043857760];
@@ -128,6 +150,14 @@ export const generateRegistrationNode = ({ registrationId, signedPreKey, signedI
 };
 export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
     const msgId = stanza.attrs.id;
+    // AunuBaileys (1.0.79, HB-80 sub-instance): the creds fields are
+    // dereferenced bare below (Buffer.from(advSecretKey, 'base64'),
+    // the identity concat/sign) — a partial creds died as a bare
+    // TypeError inside the pair-success handler. Fail descriptively,
+    // like the registration guards.
+    if (typeof advSecretKey !== 'string' || !advSecretKey || !isKeyMaterial(signedIdentityKey?.public) || !isKeyMaterial(signedIdentityKey?.private)) {
+        throw new Error('AunuBaileys: creds.advSecretKey / creds.signedIdentityKey are missing or incomplete — the auth state is incomplete or corrupt; restore a full backup or pair again');
+    }
     const pairSuccessNode = getBinaryNodeChild(stanza, 'pair-success');
     const deviceIdentityNode = getBinaryNodeChild(pairSuccessNode, 'device-identity');
     const platformNode = getBinaryNodeChild(pairSuccessNode, 'platform');
@@ -138,6 +168,19 @@ export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentit
     }
     const bizName = businessNode?.attrs.name;
     const jid = deviceNode.attrs.jid;
+    // AunuBaileys (1.0.79, HB-239): a pair-success stanza without a
+    // device jid used to store me.id = undefined SILENTLY — pairing
+    // "succeeded", and the NEXT boot took the login path and looped
+    // on the HB-43 Boom 400 forever. Reject the stanza here, where
+    // the defect is. The addendum: a device-identity node without
+    // content died as protobufjs' bare 'Error: illegal buffer' —
+    // same missing-guard class, same fix.
+    if (typeof jid !== 'string' || !jid) {
+        throw new Boom('Missing jid on the device node in pair success stanza', { data: stanza });
+    }
+    if (!deviceIdentityNode.content?.length) {
+        throw new Boom('Missing content on the device-identity node in pair success stanza', { data: stanza });
+    }
     const { details, hmac, accountType } = proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
     const isHostedAccount = accountType !== undefined && accountType === proto.ADVEncryptionType.HOSTED;
     const hmacPrefix = isHostedAccount ? Buffer.from([6, 5]) : Buffer.alloc(0);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aunucore/baileys",
   "type": "module",
-  "version": "1.0.78",
+  "version": "1.0.80",
   "description": "AunuBaileys — the self-healing WhatsApp Web API for Node.js. Bad MAC and \"2000 messages into the future\" errors repair themselves, LID and phone-number identities stay in sync, anti-ban is built in, pairing codes are custom — plus 29 experimental features no other Baileys fork ships: invisible watermarks, per-person tag-all cards, side-profile text, ghost mentions and more. ESM, CJS and full TypeScript types.",
   "keywords": [
     "whatsapp",