@aunucore/baileys 1.0.76 → 1.0.78

package/lib/Signal/Group/group-session-builder.js

@@ -7,8 +7,26 @@ export class GroupSessionBuilder {
         this.senderKeyStore = senderKeyStore;
     }
     async process(senderKeyName, senderKeyDistributionMessage) {
+        // AunuBaileys (1.0.78, HB-168): a malformed SKDM used to be
+        // stored without any validation — a missing/empty distribution
+        // message produced a junk state (keyId 0, empty chain seed,
+        // empty signing key) that passed the load-time guard, and five
+        // of them (MAX_STATES) evicted the author's good state, after
+        // which every legitimate message from that author failed with
+        // 'No session found'. Refuse anything that cannot possibly
+        // work: a numeric id and iteration, a 32-byte chain key and a
+        // 32/33-byte signing key (our own builder emits 32 + 33).
+        const id = senderKeyDistributionMessage.getId();
+        const iteration = senderKeyDistributionMessage.getIteration();
+        const chainKey = senderKeyDistributionMessage.getChainKey();
+        const signatureKey = senderKeyDistributionMessage.getSignatureKey();
+        if (!Number.isFinite(id) || !Number.isFinite(iteration) ||
+            !Buffer.isBuffer(chainKey) || chainKey.length !== 32 ||
+            !Buffer.isBuffer(signatureKey) || (signatureKey.length !== 32 && signatureKey.length !== 33)) {
+            return;
+        }
         const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
-        senderKeyRecord.addSenderKeyState(senderKeyDistributionMessage.getId(), senderKeyDistributionMessage.getIteration(), senderKeyDistributionMessage.getChainKey(), senderKeyDistributionMessage.getSignatureKey());
+        senderKeyRecord.addSenderKeyState(id, iteration, chainKey, signatureKey);
         await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
     }
     async create(senderKeyName) {

package/lib/Signal/Group/sender-chain-key.js

@@ -5,10 +5,19 @@ export class SenderChainKey {
     constructor(iteration, chainKey) {
         this.MESSAGE_KEY_SEED = Buffer.from([0x01]);
         this.CHAIN_KEY_SEED = Buffer.from([0x02]);
-        this.iteration = iteration;
+        // AunuBaileys (1.0.78, HB-162/HB-180): a stored string seed is
+        // base64 (the house format), not UTF-8 text, and a numeric
+        // string iteration must become a number — '5' + 1 === '51'
+        // concatenation poisoned the chain. Stored records are
+        // sanitised at load (sender-key-record.js); this is the same
+        // normalisation for direct constructions.
+        this.iteration = typeof iteration === 'string' && /^-?\d+$/.test(iteration.trim()) ? Number(iteration) : iteration;
         if (chainKey instanceof Buffer) {
             this.chainKey = chainKey;
         }
+        else if (typeof chainKey === 'string') {
+            this.chainKey = Buffer.from(chainKey, 'base64');
+        }
         else {
             this.chainKey = Buffer.from(chainKey || []);
         }

package/lib/Signal/Group/sender-key-distribution-message.js

@@ -8,8 +8,10 @@ export class SenderKeyDistributionMessage extends CiphertextMessage {
                 const message = serialized.slice(1);
                 const distributionMessage = proto.SenderKeyDistributionMessage.decode(message).toJSON();
                 this.serialized = serialized;
-                this.id = distributionMessage.id;
-                this.iteration = distributionMessage.iteration;
+                // AunuBaileys (1.0.78, HB-186): same proto3 default
+                // omission as SenderKeyMessage — normalise to 0.
+                this.id = distributionMessage.id ?? 0;
+                this.iteration = distributionMessage.iteration ?? 0;
                 this.chainKey =
                     typeof distributionMessage.chainKey === 'string'
                         ? Buffer.from(distributionMessage.chainKey, 'base64')

package/lib/Signal/Group/sender-key-message.js

@@ -13,8 +13,15 @@ export class SenderKeyMessage extends CiphertextMessage {
             const senderKeyMessage = proto.SenderKeyMessage.decode(message).toJSON();
             this.serialized = serialized;
             this.messageVersion = (version & 0xff) >> 4;
-            this.keyId = senderKeyMessage.id;
-            this.iteration = senderKeyMessage.iteration;
+            // AunuBaileys (1.0.78, HB-186/HB-217): proto3 encoders omit
+            // default-valued fields, so a canonical peer's id 0 /
+            // iteration 0 arrive as undefined. Normalise to 0 — an
+            // undefined iteration made getSenderKey return the CURRENT
+            // chain key (every comparison against undefined is false)
+            // and an undefined keyId selected the LAST state in the
+            // record instead of state 0.
+            this.keyId = senderKeyMessage.id ?? 0;
+            this.iteration = senderKeyMessage.iteration ?? 0;
             this.ciphertext =
                 typeof senderKeyMessage.ciphertext === 'string'
                     ? Buffer.from(senderKeyMessage.ciphertext, 'base64')

package/lib/Signal/Group/sender-key-record.js

@@ -1,5 +1,86 @@
 import { BufferJSON } from '../../Utils/generics.js';
 import { SenderKeyState } from './sender-key-state.js';
+// AunuBaileys (1.0.78, HB-124/HB-162/HB-180/HB-197): stored sender-key
+// states used to be checked for EXISTENCE only — a hand-edited or
+// corrupt sender-key-*.json could carry a number where a seed belongs
+// (raw TypeError on every group decrypt/encrypt), a base64 string the
+// chain key decoded as UTF-8 (silently wrong keys), a string iteration
+// ('5' + 1 === '51' — concatenation poisoned the chain and bricked
+// group sends with 'Over 2000 messages into the future!'), a missing
+// iteration (NaN — every SKM went out with wire iteration 0 forever),
+// or a string/missing senderKeyId (strict === lookup always missed).
+// Normalise what has a documented house format (base64 strings,
+// numeric strings) and DROP what cannot be made valid — a dropped
+// state self-heals via a fresh SKDM / a fresh own state, a poisoned
+// one never does. Key material produced by our own serializer always
+// satisfies these shapes (32-byte seeds, 32/33-byte signing public).
+const storedSeedToBuffer = (value) => Buffer.isBuffer(value)
+    ? value
+    : (typeof value === 'string' ? Buffer.from(value, 'base64') : null);
+const storedCountToNumber = (value) => {
+    if (typeof value === 'number') {
+        return Number.isInteger(value) ? value : null;
+    }
+    if (typeof value === 'string' && /^-?\d+$/.test(value.trim())) {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+};
+const sanitizeSenderKeyStructure = (structure) => {
+    const chainKey = structure.senderChainKey;
+    const signingKey = structure.senderSigningKey;
+    if (!chainKey || typeof chainKey !== 'object' || !signingKey || typeof signingKey !== 'object') {
+        return null;
+    }
+    const seed = storedSeedToBuffer(chainKey.seed);
+    if (!seed || seed.length !== 32) {
+        return null;
+    }
+    const iteration = storedCountToNumber(chainKey.iteration);
+    if (iteration === null) {
+        return null;
+    }
+    const signingPublic = storedSeedToBuffer(signingKey.public);
+    if (!signingPublic || (signingPublic.length !== 32 && signingPublic.length !== 33)) {
+        return null;
+    }
+    const cleanSigning = { public: signingPublic };
+    if (typeof signingKey.private !== 'undefined') {
+        const signingPrivate = storedSeedToBuffer(signingKey.private);
+        if (!signingPrivate || signingPrivate.length !== 32) {
+            return null;
+        }
+        cleanSigning.private = signingPrivate;
+    }
+    const keyId = storedCountToNumber(structure.senderKeyId);
+    if (keyId === null) {
+        return null;
+    }
+    // senderMessageKeys: drop individual entries that cannot be used
+    // (HB-124 addenda) instead of dropping the whole state — the chain
+    // itself is still good.
+    const messageKeys = [];
+    if (Array.isArray(structure.senderMessageKeys)) {
+        for (const entry of structure.senderMessageKeys) {
+            if (!entry || typeof entry !== 'object') {
+                continue;
+            }
+            const mkIteration = storedCountToNumber(entry.iteration);
+            const mkSeed = storedSeedToBuffer(entry.seed);
+            if (mkIteration === null || !mkSeed || mkSeed.length !== 32) {
+                continue;
+            }
+            messageKeys.push({ iteration: mkIteration, seed: mkSeed });
+        }
+    }
+    return {
+        senderKeyId: keyId,
+        senderChainKey: { iteration, seed },
+        senderSigningKey: cleanSigning,
+        senderMessageKeys: messageKeys
+    };
+};
 export class SenderKeyRecord {
     constructor(serialized) {
         this.MAX_STATES = 5;
@@ -15,11 +96,18 @@ export class SenderKeyRecord {
                 // store) used to load "fine" and then throw a bare
                 // TypeError on every group send, forever (HB-69).
                 // Skip entries that cannot possibly work.
-                if (!structure || typeof structure !== 'object' ||
-                    !structure.senderChainKey || !structure.senderSigningKey) {
+                // (1.0.78, HB-124/HB-162/HB-180/HB-197): existence is
+                // not enough — sanitise the field TYPES (see
+                // sanitizeSenderKeyStructure above) and skip states
+                // that stay invalid after normalisation.
+                if (!structure || typeof structure !== 'object') {
+                    continue;
+                }
+                const clean = sanitizeSenderKeyStructure(structure);
+                if (!clean) {
                     continue;
                 }
-                this.senderKeyStates.push(new SenderKeyState(null, null, null, null, null, null, structure));
+                this.senderKeyStates.push(new SenderKeyState(null, null, null, null, null, null, clean));
             }
         }
     }

package/lib/Signal/libsignal.js

@@ -9,8 +9,15 @@ import { GroupCipher, GroupSessionBuilder, SenderKeyDistributionMessage } from '
 // (or a string in a hand-edited creds file). Anything else is a
 // wrong-typed corrupt value, not key material.
 const isKeyMaterial = (value) => Buffer.isBuffer(value) || typeof value === 'string';
+// AunuBaileys (1.0.78, HB-157): string key material is base64 (the
+// house format) — decode it as such instead of Buffer.from()'s UTF-8,
+// which produced 44-byte garbage keys and failed every new session.
+const storedKeyToBuffer = (value) => typeof value === 'string' ? Buffer.from(value, 'base64') : value;
 export function makeLibSignalRepository(auth) {
     const storage = signalStorage(auth);
+    // AunuBaileys (1.0.78, HB-240): in-flight serialisation for
+    // encryptGroupMessage, per group — see that method.
+    const groupEncryptChains = new Map();
     return {
         decryptGroupMessage({ group, authorJid, msg }) {
             const senderName = jidToSignalSenderKeyName(group, authorJid);
@@ -55,20 +62,38 @@ export function makeLibSignalRepository(auth) {
             return { type, ciphertext: Buffer.from(body, 'binary') };
         },
         async encryptGroupMessage({ group, meId, data }) {
-            const senderName = jidToSignalSenderKeyName(group, meId);
-            const builder = new GroupSessionBuilder(storage);
-            const senderNameStr = senderName.toString();
-            const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
-            if (!senderKey) {
-                await storage.storeSenderKey(senderName, new SenderKeyRecord());
-            }
-            const senderKeyDistributionMessage = await builder.create(senderName);
-            const session = new GroupCipher(storage, senderName);
-            const ciphertext = await session.encrypt(data);
-            return {
-                ciphertext,
-                senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+            // AunuBaileys (1.0.78, HB-240): serialise per group.
+            // GroupSessionBuilder.create() runs OUTSIDE GroupCipher's
+            // per-group queueJob, so two concurrent first-sends to the
+            // same group (empty sender-key record) both created a
+            // fresh key and overwrote each other — the loser returned
+            // an SKDM that did not match the ciphertext it encrypted
+            // (which used the winner's stored state), and every peer
+            // failed that first message. Chain the whole
+            // create+encrypt per group; different groups still run in
+            // parallel.
+            const run = async () => {
+                const senderName = jidToSignalSenderKeyName(group, meId);
+                const builder = new GroupSessionBuilder(storage);
+                const senderNameStr = senderName.toString();
+                const { [senderNameStr]: senderKey } = await auth.keys.get('sender-key', [senderNameStr]);
+                if (!senderKey) {
+                    await storage.storeSenderKey(senderName, new SenderKeyRecord());
+                }
+                const senderKeyDistributionMessage = await builder.create(senderName);
+                const session = new GroupCipher(storage, senderName);
+                const ciphertext = await session.encrypt(data);
+                return {
+                    ciphertext,
+                    senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
+                };
             };
+            const prev = groupEncryptChains.get(group) ?? Promise.resolve();
+            const chained = prev.then(run);
+            // the stored chain must never stay rejected, or one failed
+            // send would poison every later send to the group
+            groupEncryptChains.set(group, chained.catch(() => { }));
+            return chained;
         },
         async deleteSenderKey(group, authorJid) {
             const senderNameStr = jidToSignalSenderKeyName(group, authorJid).toString();
@@ -133,10 +158,13 @@ function signalStorage({ creds, keys }) {
                     // classifier and misleads diagnostics. Say what is
                     // actually wrong; the 3-strike self-heal still clears
                     // the poisoned record via deleteSession.
-                    if (err instanceof TypeError) {
-                        throw new Error(`AunuBaileys: stored session record for ${id} is corrupt or malformed and cannot be deserialized; delete the session and re-establish it`);
-                    }
-                    throw err;
+                    // (1.0.78, HB-110): the conversion used to cover only
+                    // TypeError — a record with a non-v1 version throws a
+                    // plain Error('Error migrating SessionRecord') from
+                    // libsignal and escaped raw. Convert EVERY
+                    // deserialize failure; the behaviour (3-strike
+                    // self-heal) is identical, only the message improves.
+                    throw new Error(`AunuBaileys: stored session record for ${id} is corrupt or malformed and cannot be deserialized; delete the session and re-establish it`);
                 }
             }
         },
@@ -164,8 +192,8 @@ function signalStorage({ creds, keys }) {
                     return undefined;
                 }
                 return {
-                    privKey: Buffer.from(key.private),
-                    pubKey: Buffer.from(key.public)
+                    privKey: storedKeyToBuffer(key.private),
+                    pubKey: storedKeyToBuffer(key.public)
                 };
             }
         },
@@ -184,8 +212,8 @@ function signalStorage({ creds, keys }) {
                 throw new Error('AunuBaileys: creds.signedPreKey is missing or incomplete — the auth state is incomplete or corrupt; restore a full backup or pair again');
             }
             return {
-                privKey: Buffer.from(key.keyPair.private),
-                pubKey: Buffer.from(key.keyPair.public)
+                privKey: storedKeyToBuffer(key.keyPair.private),
+                pubKey: storedKeyToBuffer(key.keyPair.public)
             };
         },
         loadSenderKey: async (senderKeyName) => {
@@ -212,7 +240,7 @@ function signalStorage({ creds, keys }) {
                 throw new Error('Our signed identity key is missing or incomplete — the auth state is corrupt; re-pair the device');
             }
             return {
-                privKey: Buffer.from(signedIdentityKey.private),
+                privKey: storedKeyToBuffer(signedIdentityKey.private),
                 pubKey: generateSignalPubKey(signedIdentityKey.public)
             };
         }

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, isBadMacError, isUnrecoverableSessionError, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, buildCallControlStanza, parseRetryReceiptSession, setBotMessageSecret, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
+import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, isBadMacError, isSenderKeyUnavailableError, isUnrecoverableSessionError, keyMaterialToBuffer, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, buildCallControlStanza, parseRetryReceiptSession, setBotMessageSecret, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
 import { sentMessageCacheFor } from '../Utils/sent-message-cache.js';
 import { createOfflineNodeQueue } from '../Utils/offline-queue.js';
@@ -545,7 +545,10 @@ export const makeMessagesRecvSocket = (config) => {
                     info: 'link_code_pairing_key_bundle_encryption_key'
                 });
                 const encryptPayload = Buffer.concat([
-                    Buffer.from(authState.creds.signedIdentityKey.public),
+                    // AunuBaileys (1.0.78, HB-157): a string identity key
+                    // is base64 — Buffer.from() decoded it as UTF-8 and
+                    // put a 44-byte garbage identity in the payload.
+                    keyMaterialToBuffer(authState.creds.signedIdentityKey.public),
                     primaryIdentityPublicKey,
                     random
                 ]);
@@ -923,6 +926,16 @@ export const makeMessagesRecvSocket = (config) => {
                                         // sender key saja tidak menyentuh sesi E2E yang
                                         // rusak. Kelas ini direset SEKETIKA.
                                         const sessionLayerFailure = isUnrecoverableSessionError(msg?.messageStubParameters?.[0]);
+                                        // AunuBaileys (1.0.78, HB-223): a group
+                                        // failure where the sender key is simply
+                                        // absent (or the skmsg payload itself is
+                                        // malformed) says nothing about the
+                                        // author's E2E session — do not count it
+                                        // toward the session reset and do not
+                                        // report it as a healable failure; the
+                                        // retry receipt below is the whole fix,
+                                        // it makes the peer redistribute its key.
+                                        const senderKeyUnavailable = isGroupMsg && isSenderKeyUnavailableError(msg?.messageStubParameters?.[0]);
                                         let healed = false;
                                         const resetE2ESession = async () => {
                                             await signalRepository.deleteSession(author);
@@ -933,7 +946,10 @@ export const makeMessagesRecvSocket = (config) => {
                                                 await signalRepository.deleteSession(alt);
                                             }
                                         };
-                                        if (sessionLayerFailure) {
+                                        if (senderKeyUnavailable) {
+                                            logger.debug({ author, addr, group: msg.key.remoteJid }, 'aunu: group decrypt failed because the sender key is unavailable or the skmsg is malformed; retry receipt only, no session reset');
+                                        }
+                                        else if (sessionLayerFailure) {
                                             await resetE2ESession();
                                             if (isGroupMsg) {
                                                 await signalRepository.deleteSenderKey(msg.key.remoteJid, author);
@@ -977,6 +993,7 @@ export const makeMessagesRecvSocket = (config) => {
                                         // AunuBaileys: structured decrypt-failure event so
                                         // consumers can alert and aggregate on Bad MAC
                                         // floods (B-01) instead of parsing log lines.
+                                        if (!senderKeyUnavailable) {
                                         ev.emit('messages.decrypt-failure', {
                                             remoteJid: msg.key.remoteJid,
                                             author,
@@ -988,6 +1005,7 @@ export const makeMessagesRecvSocket = (config) => {
                                             messageId: node.attrs.id,
                                             timestamp: Date.now()
                                         });
+                                        }
                                     }
                                     catch (healErr) {
                                         logger.debug({ err: healErr }, 'aunu: session self-heal step failed, continuing with normal retry');

package/lib/Socket/messages-send.js

@@ -334,12 +334,23 @@ export const makeMessagesSocket = (config) => {
             // the transport to reopen, bounded by connectTimeoutMs; a connection
             // that closes for good still fails fast via waitForSocketOpen itself.
             const waitMs = config.connectTimeoutMs ?? 60000;
-            await Promise.race([
-                waitForSocketOpen(),
-                delay(waitMs).then(() => {
-                    throw new Boom(`Timed out waiting ${waitMs}ms for the connection to open before sending`, { statusCode: 408 }); // 408 = DisconnectReason.timedOut
-                })
-            ]);
+            const openWait = waitForSocketOpen();
+            try {
+                await Promise.race([
+                    openWait,
+                    delay(waitMs).then(() => {
+                        throw new Boom(`Timed out waiting ${waitMs}ms for the connection to open before sending`, { statusCode: 408 }); // 408 = DisconnectReason.timedOut
+                    })
+                ]);
+            }
+            catch (err) {
+                // AunuBaileys (1.0.77, HB-167): when the timeout wins,
+                // the socket-open waiter is still pending — detach its
+                // ws listeners now instead of leaving three behind per
+                // failed send until the socket settles on its own.
+                openWait.cancel?.();
+                throw err;
+            }
         }
         // AunuBaileys (1.0.68): fail with a clear Boom instead of a raw
         // TypeError when sending before pairing completes or with a
@@ -528,7 +539,17 @@ export const makeMessagesSocket = (config) => {
                     attrs: { v: '2', type: 'skmsg' },
                     content: ciphertext
                 });
-                await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } });
+                // AunuBaileys (1.0.78, HB-132/HB-155): persist the map
+                // only when it was actually loaded from the store
+                // (same condition as the load above). A participant-
+                // targeted send starts from {} without loading, so
+                // writing its partial map back overwrote the full
+                // memo — and silently undid sendMessagesAgain's
+                // deliberate null, which exists to force a full
+                // redistribution on the next normal send.
+                if (!participant && !isStatus) {
+                    await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } });
+                }
             }
             else {
                 const meUser = jidDecode(meId)?.user;

package/lib/Socket/socket.js

@@ -9,7 +9,7 @@ import { executeWMexQuery } from './mex.js';
 import { makeLIDStore } from '../Utils/lid-store.js';
 import { createIgnoreFilter } from '../Utils/ignore-filter.js';
 import { QueryIds, XWAPaths } from '../Types/index.js';
-import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode, getPlatformId, fetchLatestWaWebVersion, makeEventBuffer, makeNoiseHandler, promiseTimeout } from '../Utils/index.js';
+import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode, getPlatformId, fetchLatestWaWebVersion, keyMaterialToBuffer, makeEventBuffer, makeNoiseHandler, promiseTimeout } from '../Utils/index.js';
 import { assertNodeErrorFree, binaryNodeToString, encodeBinaryNode, getBinaryNodeChild, getBinaryNodeChildren, jidEncode, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { WebSocketClient } from './Client/index.js';
 /**
@@ -92,6 +92,15 @@ export const makeSocket = (config) => {
     let epoch = 1;
     let keepAliveReq;
     let qrTimer;
+    // AunuBaileys (1.0.77, HB-243): true while a pair-device QR chain
+    // is cycling — a duplicate pair-device IQ must not start a second
+    // chain on the shared qrTimer slot.
+    let qrChainActive = false;
+    // AunuBaileys (1.0.77, HB-213): resolved when the Noise handshake
+    // completes (finishInit in validateConnection), so the pairing
+    // request can wait for an encrypted channel.
+    let resolveHandshakeComplete;
+    const handshakeComplete = new Promise((resolve) => { resolveHandshakeComplete = resolve; });
     let closed = false;
     let lastDisconnectError;
     const uqTagId = generateMdTagPrefix();
@@ -226,6 +235,7 @@ export const makeSocket = (config) => {
             }
         }).finish());
         noise.finishInit();
+        resolveHandshakeComplete?.();
         startKeepAliveRequest();
     };
     const getAvailablePreKeysOnServer = async () => {
@@ -278,12 +288,17 @@ export const makeSocket = (config) => {
             await uploadPreKeys();
         }
     };
+    // AunuBaileys (1.0.77, HB-156): decodeFrame invocations must never
+    // overlap — the noise handler slices ONE shared inBytes buffer, so
+    // two concurrent calls interleave and deliver stanzas out of wire
+    // order. Every WS message is chained through a single queue.
+    let frameDecodeChain = Promise.resolve();
     const onMessageReceived = (data) => {
         // AunuBaileys (1.0.67): decodeFrame is async — a malformed frame
         // (bad GCM tag, truncated binary node) or a throwing frame
         // listener must not become an unhandled rejection that kills
         // the process; route failures to onUnexpectedError instead.
-        Promise.resolve(noise.decodeFrame(data, frame => {
+        frameDecodeChain = frameDecodeChain.then(() => noise.decodeFrame(data, frame => {
             // reset ping timeout
             lastDateRecv = new Date();
             let anyTriggered = false;
@@ -311,7 +326,20 @@ export const makeSocket = (config) => {
                     logger.debug({ unhandled: true, msgId, fromMe: false, frame }, 'communication recv');
                 }
             }
-        })).catch(err => onUnexpectedError(err, 'onMessageReceived'));
+        })).catch(err => {
+            // AunuBaileys (1.0.77, HB-185/HB-207): a frame-layer failure
+            // (oversize header, GCM decrypt failure) leaves the noise
+            // stream unrecoverable — the header is never consumed, or
+            // the read counter desyncs so every later frame fails too.
+            // End the connection so the host reconnects at once instead
+            // of wedging until the keep-alive watchdog notices (~65s).
+            if (err?.isFrameFatal) {
+                end(err);
+            }
+            else {
+                onUnexpectedError(err, 'onMessageReceived');
+            }
+        });
     };
     // AunuBaileys: socket end handlers (pola v7) + fetch Mex (dari @itsliaaa/baileys)
     const socketEndHandlers = [];
@@ -329,6 +357,7 @@ export const makeSocket = (config) => {
         logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
         clearInterval(keepAliveReq);
         clearTimeout(qrTimer);
+        qrChainActive = false;
         ws.removeAllListeners('close');
         ws.removeAllListeners('open');
         ws.removeAllListeners('message');
@@ -354,16 +383,20 @@ export const makeSocket = (config) => {
         ev.removeAllListeners('connection.update');
         ev.destroy?.();
     };
-    const waitForSocketOpen = async () => {
+    const waitForSocketOpen = () => {
         if (ws.isOpen) {
-            return;
+            const resolved = Promise.resolve();
+            resolved.cancel = () => { };
+            return resolved;
         }
         if (ws.isClosed || ws.isClosing) {
-            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
+            const rejected = Promise.reject(new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
+            rejected.cancel = () => { };
+            return rejected;
         }
         let onOpen;
         let onClose;
-        await new Promise((resolve, reject) => {
+        const promise = new Promise((resolve, reject) => {
             onOpen = () => resolve(undefined);
             onClose = mapWebSocketError(reject);
             ws.on('open', onOpen);
@@ -374,6 +407,16 @@ export const makeSocket = (config) => {
             ws.off('close', onClose);
             ws.off('error', onClose);
         });
+        // AunuBaileys (1.0.77, HB-167/HB-179): a caller that stops
+        // waiting (its own timeout won the race) can detach these
+        // listeners immediately instead of leaving them on the ws
+        // emitter until the socket happens to open/close/error.
+        promise.cancel = () => {
+            ws.off('open', onOpen);
+            ws.off('close', onClose);
+            ws.off('error', onClose);
+        };
+        return promise;
     };
     const keepAliveTick = () => {
         if (!lastDateRecv) {
@@ -501,15 +544,55 @@ export const makeSocket = (config) => {
                 reject(new Boom(`requestPairingCode: socket did not open within ${PAIRING_READY_TIMEOUT_MS / 1000}s (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.timedOut }));
             }, PAIRING_READY_TIMEOUT_MS);
         });
+        const rawOpenWait = waitForSocketOpen();
         try {
             await Promise.race([
-                waitForSocketOpen().catch(() => {
+                rawOpenWait.catch(() => {
                     throw new Boom(`requestPairingCode: connection closed while waiting for the socket to open (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.connectionClosed });
                 }),
                 closedWhileWaiting,
                 timedOut
             ]);
         }
+        finally {
+            clearTimeout(timer);
+            // AunuBaileys (1.0.77, HB-179): if the timeout or the close
+            // guard won the race, the socket-open waiter is still
+            // pending — detach its ws listeners now instead of leaving
+            // them behind until the socket settles on its own.
+            rawOpenWait.cancel?.();
+            if (onUpdate) {
+                try {
+                    ev.off('connection.update', onUpdate);
+                }
+                catch { }
+            }
+        }
+    };
+    // AunuBaileys (1.0.77, HB-213): the pairing IQ must not leave
+    // before the Noise handshake completes — encodeFrame encrypts
+    // only once the handshake is finished, so an early IQ travels as
+    // a plaintext binary node; a strict server kills the connection
+    // over it while requestPairingCode still resolves with the code.
+    const waitForHandshakeComplete = async () => {
+        let onUpdate;
+        const closedWhileWaiting = new Promise((_, reject) => {
+            onUpdate = (update) => {
+                if (update.connection === 'close') {
+                    reject(new Boom(`requestPairingCode: connection closed while waiting for the handshake to complete (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.connectionClosed }));
+                }
+            };
+            ev.on('connection.update', onUpdate);
+        });
+        let timer;
+        const timedOut = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                reject(new Boom(`requestPairingCode: handshake did not complete within ${PAIRING_READY_TIMEOUT_MS / 1000}s (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.timedOut }));
+            }, PAIRING_READY_TIMEOUT_MS);
+        });
+        try {
+            await Promise.race([handshakeComplete, closedWhileWaiting, timedOut]);
+        }
         finally {
             clearTimeout(timer);
             if (onUpdate) {
@@ -534,13 +617,20 @@ export const makeSocket = (config) => {
         pairingCodeRequestInFlight = true;
         try {
         await waitForPairingReady();
+        await waitForHandshakeComplete();
         authState.creds.pairingCode = pairingCode;
         authState.creds.me = {
             id: jidEncode(phoneNumber, 's.whatsapp.net'),
             name: '~'
         };
         ev.emit('creds.update', authState.creds);
-        await sendNode({
+        // AunuBaileys (1.0.77, HB-191): query(), not sendNode() — the
+        // companion_hello result must be awaited and error-checked.
+        // sendNode resolved when the bytes hit the wire, so a server
+        // rejection left the optimistic creds.me/pairingCode persisted
+        // and sent the next boot into a 401 loop; a rejection now
+        // lands in the catch below, which rolls the creds back.
+        await query({
             tag: 'iq',
             attrs: {
                 to: S_WHATSAPP_NET,
@@ -644,6 +734,16 @@ export const makeSocket = (config) => {
         }
     });
     ws.on('error', mapWebSocketError(end));
+    // AunuBaileys (1.0.77, HB-189): the ws client forwards
+    // 'unexpected-response', which suppresses ws's own handshake
+    // abort — without a listener here a non-101 response (403/502,
+    // ISP intercept page) wedges the socket in 'connecting' forever:
+    // no open, no error, no close, and the host never reconnects.
+    ws.on('unexpected-response', (_req, res) => {
+        const code = res?.statusCode;
+        const statusCode = Number.isFinite(code) && code >= 400 && code <= 599 ? code : 500;
+        end(new Boom(`Unexpected server response: ${code}`, { statusCode }));
+    });
     ws.on('close', () => end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
     // the server terminated the connection
     ws.on('CB:xmlstreamend', () => end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
@@ -662,14 +762,28 @@ export const makeSocket = (config) => {
             }
         };
         await sendNode(iq);
+        // AunuBaileys (1.0.77, HB-243): a duplicate pair-device IQ
+        // (server retry) must not start a parallel QR chain — both
+        // chains share the single qrTimer slot, so the orphaned first
+        // chain keeps cycling after login and its ref exhaustion ends
+        // the healthy, freshly logged-in connection.
+        if (qrChainActive) {
+            logger.warn('ignoring duplicate pair-device IQ: a QR chain is already running');
+            return;
+        }
+        qrChainActive = true;
         const pairDeviceNode = getBinaryNodeChild(stanza, 'pair-device');
         const refNodes = getBinaryNodeChildren(pairDeviceNode, 'ref');
-        const noiseKeyB64 = Buffer.from(creds.noiseKey.public).toString('base64');
-        const identityKeyB64 = Buffer.from(creds.signedIdentityKey.public).toString('base64');
+        // AunuBaileys (1.0.78, HB-157): a string key is base64 already —
+        // Buffer.from() re-encoded its UTF-8 bytes, putting a wrong
+        // noise/identity key into every QR code.
+        const noiseKeyB64 = keyMaterialToBuffer(creds.noiseKey.public).toString('base64');
+        const identityKeyB64 = keyMaterialToBuffer(creds.signedIdentityKey.public).toString('base64');
         const advB64 = creds.advSecretKey;
         let qrMs = qrTimeout || 60000; // time to let a QR live
         const genPairQR = () => {
             if (!ws.isOpen) {
+                qrChainActive = false;
                 return;
             }
             const refNode = refNodes.shift();
@@ -726,6 +840,7 @@ export const makeSocket = (config) => {
             await sendPassiveIq('active');
             logger.info('opened connection to WA');
             clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
+            qrChainActive = false;
             ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } });
             ev.emit('connection.update', { connection: 'open' });
         }
@@ -737,9 +852,9 @@ export const makeSocket = (config) => {
     // AunuBaileys (1.0.71): 405 client_too_old — fetch the live WA Web
     // build so the caller's reconnect uses it (donor: violetix
     // lib/Socket/socket.js CB:failure handler). Only for static versions;
-    // a resolver function re-resolves on the next connect anyway. The
-    // connection.update signal is best-effort: end() may already have
-    // torn the listeners down by the time the fetch lands.
+    // a resolver function re-resolves on the next connect anyway. Both
+    // 405 paths (CB:failure and CB:stream:error) await this before
+    // end(), so the clientTooOld signal reaches the host first.
     const handleClientTooOld = async () => {
         if (typeof config.version === 'function') {
             return;
@@ -759,11 +874,16 @@ export const makeSocket = (config) => {
             logger.warn({ err }, 'failed to fetch the latest WA Web version after a 405');
         }
     };
-    ws.on('CB:stream:error', (node) => {
+    ws.on('CB:stream:error', async (node) => {
         logger.error({ node }, 'stream errored out');
         const { reason, statusCode } = getErrorCodeFromStreamError(node);
         if (statusCode === 405) {
-            void handleClientTooOld();
+            // AunuBaileys (1.0.77, HB-148): awaited like the CB:failure
+            // path (1.0.72) — firing it void let end() tear the
+            // connection.update listeners down before the version
+            // fetch landed, so the clientTooOld signal never reached
+            // the host and a 405 looked like any other disconnect.
+            await handleClientTooOld();
         }
         end(new Boom(`Stream Errored (${reason})`, { statusCode, data: node }));
     });
@@ -802,7 +922,7 @@ export const makeSocket = (config) => {
         if (offlineDrainBatches >= OFFLINE_DRAIN_MAX_BATCHES) {
             stopOfflineDrain();
             logger.warn({ batches: offlineDrainBatches }, 'offline drain hit the batch cap; remaining backlog waits for the next reconnect');
-            return;
+            return false;
         }
         offlineDrainBatches += 1;
         // AunuBaileys (1.0.70): a floating sendNode here could reject
@@ -812,12 +932,19 @@ export const makeSocket = (config) => {
             attrs: {},
             content: [{ tag: 'offline_batch', attrs: { count: '100' } }]
         }).catch(err => logger.warn({ err }, 'failed to request offline batch'));
+        return true;
     };
     const scheduleOfflineDrain = () => {
         stopOfflineDrain();
         offlineDrainTimer = setTimeout(() => {
-            requestOfflineBatch();
-            scheduleOfflineDrain();
+            // AunuBaileys (1.0.77, HB-109): stop re-arming at the batch
+            // cap — the unconditional re-schedule used to undo
+            // requestOfflineBatch's stopOfflineDrain(), so when the
+            // terminal offline bulletin never arrived the cap warning
+            // repeated every 500ms for the life of the socket.
+            if (requestOfflineBatch()) {
+                scheduleOfflineDrain();
+            }
         }, OFFLINE_DRAIN_INTERVAL_MS);
     };
     ws.on('CB:ib,,offline_preview', (node) => {

package/lib/Utils/crypto.d.ts

@@ -1,4 +1,5 @@
 import type { KeyPair } from '../Types/index.js';
+export declare const keyMaterialToBuffer: (key: unknown) => unknown;
 /** prefix version byte to the pub keys, required for some curve crypto functions */
 export declare const generateSignalPubKey: (pubKey: Uint8Array | Buffer) => Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>;
 export declare const Curve: {

package/lib/Utils/crypto.js

@@ -4,6 +4,18 @@ import * as libsignal from 'libsignal';
 import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
 // insure browser & node compatibility
 const { subtle } = globalThis.crypto;
+/**
+ * AunuBaileys (1.0.78, HB-157): the house format for string key
+ * material is base64 (that is how advSecretKey and every displayed
+ * key are stored), but several consumers decoded strings with plain
+ * Buffer.from() — UTF-8 — producing wrong-length garbage keys.
+ * Decode strings as base64 everywhere; Buffers pass through and
+ * anything else is returned untouched so the callers' own type
+ * guards (HB-98) still fire.
+ */
+export const keyMaterialToBuffer = (key) => Buffer.isBuffer(key)
+    ? key
+    : (typeof key === 'string' ? Buffer.from(key, 'base64') : key);
 /** prefix version byte to the pub keys, required for some curve crypto functions */
 export const generateSignalPubKey = (pubKey) => {
     // AunuBaileys (1.0.74): HB-98 — a wrong-typed public key (e.g. a
@@ -14,7 +26,7 @@ export const generateSignalPubKey = (pubKey) => {
     if (!Buffer.isBuffer(pubKey) && typeof pubKey !== 'string') {
         throw new Error('AunuBaileys: invalid public key material — the auth state is incomplete or corrupt; restore a full backup or pair again');
     }
-    const buf = typeof pubKey === 'string' ? Buffer.from(pubKey) : pubKey;
+    const buf = keyMaterialToBuffer(pubKey);
     return buf.length === 33 ? buf : Buffer.concat([KEY_BUNDLE_TYPE, buf]);
 };
 export const Curve = {
@@ -27,10 +39,16 @@ export const Curve = {
         };
     },
     sharedKey: (privateKey, publicKey) => {
-        const shared = libsignal.curve.calculateAgreement(generateSignalPubKey(publicKey), privateKey);
+        // AunuBaileys (1.0.78, HB-214): the private key used to be
+        // passed to libsignal RAW — a base64-string private key in a
+        // hand-edited/migrated creds file died as
+        // 'Invalid private key type: String' at every handshake,
+        // pairing and pair-success call site. Decode it like every
+        // other key material (HB-157).
+        const shared = libsignal.curve.calculateAgreement(generateSignalPubKey(publicKey), keyMaterialToBuffer(privateKey));
         return Buffer.from(shared);
     },
-    sign: (privateKey, buf) => libsignal.curve.calculateSignature(privateKey, buf),
+    sign: (privateKey, buf) => libsignal.curve.calculateSignature(keyMaterialToBuffer(privateKey), buf),
     verify: (pubKey, message, signature) => {
         try {
             libsignal.curve.verifySignature(generateSignalPubKey(pubKey), message, signature);

package/lib/Utils/decode-wa-message.d.ts

@@ -7,6 +7,7 @@ export declare const getBotRecentSecretsChatCount: () => number;
 export declare const NO_MESSAGE_FOUND_ERROR_TEXT = "Message absent from node";
 export declare const isUnrecoverableSessionError: (text: unknown) => boolean;
 export declare const isBadMacError: (text: unknown) => boolean;
+export declare const isSenderKeyUnavailableError: (text: unknown) => boolean;
 export declare const MISSING_KEYS_ERROR_TEXT = "Key used already or never filled";
 export declare const NACK_REASONS: {
     ParsingError: number;

package/lib/Utils/decode-wa-message.js

@@ -429,4 +429,19 @@ export const isUnrecoverableSessionError = (text) => typeof text === 'string' &&
  * classic symptom of a desynchronised ratchet on either side.
  */
 export const isBadMacError = (text) => typeof text === 'string' && /bad mac/i.test(text);
+/**
+ * AunuBaileys (1.0.78, HB-223): true when a GROUP decrypt failure says
+ * nothing about the author's 1-1 E2E session — the sender key simply
+ * is not here yet (no record, or no state for that author: they just
+ * joined, or our own self-heal deleted it), or the skmsg payload
+ * itself is malformed (proto decode error, signature shape). Counting
+ * these toward the 3-strike session reset deleted healthy E2E
+ * sessions and reported a misleading `healed: true`; the only correct
+ * response is the retry receipt, which makes the peer redistribute
+ * its sender key. The CIPHERTEXT stub upsert still happens.
+ */
+export const isSenderKeyUnavailableError = (text) => typeof text === 'string' &&
+    (/no session found to decrypt message|no senderkeyrecord found for decryption/i.test(text) ||
+        /^invalid signature!?$/i.test(text.trim()) ||
+        /invalid wire type|index out of range/i.test(text));
 //# sourceMappingURL=decode-wa-message.js.map

package/lib/Utils/generics.js

@@ -374,6 +374,16 @@ export const getCallStatusFromNode = ({ tag, attrs }) => {
 };
 const UNEXPECTED_SERVER_CODE_TEXT = 'Unexpected server response: ';
 export const getCodeFromWSError = (error) => {
+    // AunuBaileys (1.0.77, HB-133): an error that already carries a
+    // valid Boom status code keeps it. Re-deriving the code from the
+    // message text lost real codes — promiseTimeout's Boom
+    // 'Timed Out' (408) was re-wrapped as a 500 by mapWebSocketError
+    // because the textual timeout check below is case-sensitive
+    // ('Timed Out' vs 'timed out').
+    const existingCode = error?.output?.statusCode;
+    if (Number.isFinite(existingCode) && existingCode >= 400 && existingCode <= 599) {
+        return existingCode;
+    }
     let statusCode = 500;
     if (error?.message?.includes(UNEXPECTED_SERVER_CODE_TEXT)) {
         const code = +error?.message.slice(UNEXPECTED_SERVER_CODE_TEXT.length);
@@ -385,7 +395,7 @@ export const getCodeFromWSError = (error) => {
     // AunuBaileys (1.0.67): error.code can be numeric (e.g. WS close
     // 1006) — only call startsWith on strings.
     (typeof error?.code === 'string' && error.code.startsWith('E')) ||
-        error?.message?.includes('timed out')) {
+        error?.message?.toLowerCase().includes('timed out')) {
         // handle ETIMEOUT, ENOTFOUND etc
         statusCode = 408;
     }

package/lib/Utils/noise-handler.js

@@ -15,8 +15,8 @@ const generateIV = (counter) => {
 // corrupt header either wedges the stream forever (size 0: the header
 // is never consumed, so every later call re-reads it) or buffers
 // without bound waiting for megabytes that never arrive. Fail loudly
-// instead: the socket ends (the caller routes the throw to
-// onUnexpectedError) and the host reconnects.
+// instead: the throw is marked frame-fatal (1.0.77, HB-185) and the
+// caller ends the socket, so the host reconnects at once.
 const MAX_NOISE_FRAME_SIZE = 10 * 1024 * 1024;
 export const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, logger, routingInfo }) => {
     logger = logger.child({ class: 'ns' });
@@ -161,23 +161,55 @@ export const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publi
                 }
                 if (size > MAX_NOISE_FRAME_SIZE) {
                     // AunuBaileys (1.0.73, HB-91): never wait for a
-                    // frame that cannot exist — throw so the socket
-                    // ends instead of buffering without bound until
-                    // the keep-alive watchdog kills the connection
-                    // ~65s later.
-                    throw new Boom(`noise frame too large: ${size} bytes`, { statusCode: 400 });
+                    // frame that cannot exist. (1.0.77, HB-185): the
+                    // throw alone did NOT end the socket — the caller
+                    // only logged it, the header was never consumed,
+                    // and the stream wedged until the keep-alive
+                    // watchdog fired ~65s later. Marked frame-fatal:
+                    // the caller now ends the connection on it.
+                    const err = new Boom(`noise frame too large: ${size} bytes`, { statusCode: 400 });
+                    err.isFrameFatal = true;
+                    throw err;
                 }
                 if (inBytes.length < size + 3) {
                     break;
                 }
                 let frame = inBytes.slice(3, size + 3);
                 inBytes = inBytes.slice(size + 3);
+                let decoded = true;
                 if (isFinished) {
-                    const result = decrypt(frame);
-                    frame = await decodeBinaryNode(result);
+                    let result;
+                    try {
+                        result = decrypt(frame);
+                    }
+                    catch (err) {
+                        // AunuBaileys (1.0.77, HB-207): a GCM failure
+                        // leaves readCounter behind the server's
+                        // counter, so every later frame decrypts with
+                        // the wrong IV and fails too — the stream can
+                        // never resync. Frame-fatal: the caller ends
+                        // the connection instead of losing every
+                        // inbound message until the watchdog fires.
+                        err.isFrameFatal = true;
+                        throw err;
+                    }
+                    try {
+                        frame = await decodeBinaryNode(result);
+                    }
+                    catch (err) {
+                        // AunuBaileys (1.0.77): stanza-level corruption
+                        // is NOT fatal — the frame was consumed and the
+                        // counter advanced, so the stream is still in
+                        // sync. Log and skip the frame instead of
+                        // aborting the rest of the buffered frames.
+                        logger.error({ err }, 'failed to decode a stanza; skipping the frame');
+                        decoded = false;
+                    }
+                }
+                if (decoded) {
+                    logger.trace({ msg: frame?.attrs?.id }, 'recv frame');
+                    onFrame(frame);
                 }
-                logger.trace({ msg: frame?.attrs?.id }, 'recv frame');
-                onFrame(frame);
                 size = getBytesSize();
             }
         }

package/lib/Utils/signal.js

@@ -1,6 +1,6 @@
 import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
 import { assertNodeErrorFree, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildUInt, jidDecode, S_WHATSAPP_NET } from '../WABinary/index.js';
-import { Curve, generateSignalPubKey } from './crypto.js';
+import { Curve, generateSignalPubKey, keyMaterialToBuffer } from './crypto.js';
 import { encodeBigEndian } from './generics.js';
 // AunuBaileys (1.0.74): HB-98 — key material is only ever a Buffer
 // (or a string in a hand-edited creds file). Anything else is a
@@ -52,10 +52,13 @@ export const generateOrGetPreKeys = (creds, range) => {
 export const xmppSignedPreKey = (key) => ({
     tag: 'skey',
     attrs: {},
+    // AunuBaileys (1.0.78, HB-157): key material may be a base64 string
+    // in a hand-edited creds file — the node writer would otherwise
+    // publish the base64 TEXT as the key bytes.
     content: [
         { tag: 'id', attrs: {}, content: encodeBigEndian(key.keyId, 3) },
-        { tag: 'value', attrs: {}, content: key.keyPair.public },
-        { tag: 'signature', attrs: {}, content: key.signature }
+        { tag: 'value', attrs: {}, content: keyMaterialToBuffer(key.keyPair.public) },
+        { tag: 'signature', attrs: {}, content: keyMaterialToBuffer(key.signature) }
     ]
 });
 export const xmppPreKey = (pair, id) => ({
@@ -63,7 +66,7 @@ export const xmppPreKey = (pair, id) => ({
     attrs: {},
     content: [
         { tag: 'id', attrs: {}, content: encodeBigEndian(id, 3) },
-        { tag: 'value', attrs: {}, content: pair.public }
+        { tag: 'value', attrs: {}, content: keyMaterialToBuffer(pair.public) }
     ]
 });
 /** AunuBaileys: parse the E2E key bundle embedded in a retry receipt.
@@ -239,7 +242,7 @@ export const getNextPreKeysNode = async (state, count) => {
         content: [
             { tag: 'registration', attrs: {}, content: encodeBigEndian(creds.registrationId) },
             { tag: 'type', attrs: {}, content: KEY_BUNDLE_TYPE },
-            { tag: 'identity', attrs: {}, content: creds.signedIdentityKey.public },
+            { tag: 'identity', attrs: {}, content: keyMaterialToBuffer(creds.signedIdentityKey.public) },
             { tag: 'list', attrs: {}, content: Object.keys(preKeys).map(k => xmppPreKey(preKeys[+k], +k)) },
             xmppSignedPreKey(creds.signedPreKey)
         ]

package/lib/Utils/validate-connection.js

@@ -3,7 +3,7 @@ import { createHash } from 'crypto';
 import { proto } from '../../WAProto/index.js';
 import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
 import { getBinaryNodeChild, jidDecode, S_WHATSAPP_NET } from '../WABinary/index.js';
-import { Curve, hmacSign } from './crypto.js';
+import { Curve, hmacSign, keyMaterialToBuffer } from './crypto.js';
 import { encodeBigEndian } from './generics.js';
 import { createSignalIdentity } from './signal.js';
 // AunuBaileys (1.0.74): HB-98 — key material is only ever a Buffer
@@ -147,12 +147,14 @@ export const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentit
     }
     const account = proto.ADVSignedDeviceIdentity.decode(details);
     const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
-    const accountMsg = Buffer.concat([Buffer.from([6, 0]), deviceDetails, signedIdentityKey.public]);
+    // AunuBaileys (1.0.78, HB-157): a string identity key is base64 —
+    // the raw concat used to die with a TypeError on string creds.
+    const accountMsg = Buffer.concat([Buffer.from([6, 0]), deviceDetails, keyMaterialToBuffer(signedIdentityKey.public)]);
     if (!Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
         throw new Boom('Failed to verify account signature');
     }
     const devicePrefix = isHostedAccount ? Buffer.from([6, 6]) : Buffer.from([6, 1]);
-    const deviceMsg = Buffer.concat([devicePrefix, deviceDetails, signedIdentityKey.public, accountSignatureKey]);
+    const deviceMsg = Buffer.concat([devicePrefix, deviceDetails, keyMaterialToBuffer(signedIdentityKey.public), accountSignatureKey]);
     account.deviceSignature = Curve.sign(signedIdentityKey.private, deviceMsg);
     const identity = createSignalIdentity(jid, accountSignatureKey);
     const accountEnc = encodeSignedDeviceIdentity(account, false);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aunucore/baileys",
   "type": "module",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "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",