aunubaileys 1.0.8 → 1.0.10

package/README.md

@@ -64,6 +64,14 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🆕 What's new in 1.0.10 / Baru di 1.0.10
+
+- 🛠️ **Reliability hardening against classic upstream weaknesses** — (1) **Retry receipts now get answered even without a custom `getMessage` store:** a built-in per-socket sent-message cache (last 256 relayed messages, whatsmeow-style) backs up your store, ending the silent "message not available" failures behind stuck unreadable/undelivered messages. Disable with `sentMessagesCacheSize: 0`. (2) **Pairing is now single-flight:** `requestPairingCode` refuses to double-fire (double requests invalidate the first code) and refuses outright on already-registered sessions, with clear errors instead of silent corruption. (3) **Handshake timeout raised:** default `connectTimeoutMs` goes 20s → 60s so pairing no longer times out on slow networks.
+
+### 🆕 What's new in 1.0.9 / Baru di 1.0.9
+
+- 🪪 **LID identity layer** — WhatsApp is migrating identities from phone numbers to LIDs, and incoming stanzas already carry both forms. AunuBaileys now learns the mapping from live traffic: every socket exposes `sock.aunuLid`, a bidirectional PN <-> LID store with local `getLIDForPN()` / `getPNForLID()` lookups (no extra server queries), LRU capping, and optional JSON persistence. Prefer a standalone store? `makeLIDStore()` is exported from the package root, fully typed.
+
 ### 🆕 What's new in 1.0.8 / Baru di 1.0.8
 
 - 🩹 **TypeScript declaration fix** — `NEWSLETTER_MEDIA_PATH_MAP` and `BIZ_BOT_SUPPORT_PAYLOAD` were exported from the runtime but missing from `lib/Defaults/index.d.ts`, so TypeScript consumers got compile errors importing them. Both are now properly declared. Found by the RafaelPivots automation, verified against source, no runtime changes.

package/lib/Defaults/index.js

@@ -30,7 +30,7 @@ export const DEFAULT_CONNECTION_CONFIG = {
     version: version,
     browser: Browsers.ubuntu('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
-    connectTimeoutMs: 20000,
+    connectTimeoutMs: 60000,
     keepAliveIntervalMs: 30000,
     logger: logger.child({ class: 'baileys' }),
     emitOwnEvents: true,

package/lib/Socket/index.js

@@ -1,6 +1,7 @@
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
 import { makeCommunitiesSocket } from './communities.js';
 import { AunuHandler } from '../Utils/aunu-handler.js';
+import { makeLIDStore } from '../Utils/lid-store.js';
 // export the last socket layer
 const makeWASocket = (config) => {
     const newConfig = {
@@ -14,6 +15,15 @@ const makeWASocket = (config) => {
     }
     const sock = makeCommunitiesSocket(newConfig);
     sock.aunuHandler = new AunuHandler(sock);
+    sock.aunuLid = makeLIDStore();
+    sock.ev.on('messages.upsert', (upsert) => {
+        try {
+            sock.aunuLid.learnFromUpsert(upsert);
+        }
+        catch {
+            // identity learning must never break message handling
+        }
+    });
     return sock;
 };
 export default makeWASocket;

package/lib/Socket/messages-recv.js

@@ -7,6 +7,7 @@ import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT } from '../Defaul
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
 import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
+import { sentMessageCacheFor } from '../Utils/sent-message-cache.js';
 import { areJidsSameUser, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidStatusBroadcast, isJidUser, isLidUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { extractGroupMetadata } from './groups.js';
 import { makeMessagesSocket } from './messages-send.js';
@@ -465,7 +466,7 @@ export const makeMessagesRecvSocket = (config) => {
     };
     const sendMessagesAgain = async (key, ids, retryNode) => {
         // todo: implement a cache to store the last 256 sent messages (copy whatsmeow)
-        const msgs = await Promise.all(ids.map(id => getMessage({ ...key, id })));
+        const msgs = await Promise.all(ids.map(async (id) => (await getMessage({ ...key, id })) ?? sentMessageCacheFor(config).get(key.remoteJid, id)));
         const remoteJid = key.remoteJid;
         const participant = key.participant || remoteJid;
         // if it's the primary jid sending the request

package/lib/Socket/messages-send.js

@@ -3,6 +3,7 @@ import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
 import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, delay, extractDeviceJids, generateMessageIDV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
+import { sentMessageCacheFor } from '../Utils/sent-message-cache.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isJidGroup, isJidNewsletter, isJidUser, isLidUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
@@ -311,6 +312,7 @@ export const makeMessagesSocket = (config) => {
                 };
                 logger.debug({ msgId }, `sending newsletter message to ${jid}`);
                 await sendNode(stanza);
+                sentMessageCacheFor(config).add(jid, msgId, message);
                 return;
             }
             if (normalizeMessageContent(message)?.pinInChatMessage) {
@@ -486,6 +488,7 @@ export const makeMessagesSocket = (config) => {
             logger.debug({ msgId }, `sending message to ${participants.length} devices`);
             await sendNode(stanza);
         });
+        sentMessageCacheFor(config).add(jid, msgId, message);
         return msgId;
     };
     const getMessageType = (message) => {

package/lib/Socket/socket.js

@@ -370,11 +370,20 @@ export const makeSocket = (config) => {
         }
         end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
     };
+    let pairingCodeRequestInFlight = false;
     const requestPairingCode = async (phoneNumber, customPairingCode) => {
+        if (authState.creds.registered) {
+            throw new Error('requestPairingCode: this session is already registered — pairing codes are only for new logins');
+        }
+        if (pairingCodeRequestInFlight) {
+            throw new Error('requestPairingCode: a pairing code request is already in flight — wait for it to finish instead of firing another one (double requests invalidate the first code)');
+        }
         const pairingCode = customPairingCode ?? bytesToCrockford(randomBytes(5));
         if (customPairingCode && customPairingCode?.length !== 8) {
             throw new Error('Custom pairing code must be exactly 8 chars');
         }
+        pairingCodeRequestInFlight = true;
+        try {
         authState.creds.pairingCode = pairingCode;
         authState.creds.me = {
             id: jidEncode(phoneNumber, 's.whatsapp.net'),
@@ -428,6 +437,10 @@ export const makeSocket = (config) => {
             ]
         });
         return authState.creds.pairingCode;
+        }
+        finally {
+            pairingCodeRequestInFlight = false;
+        }
     };
     async function generatePairingKey() {
         const salt = randomBytes(32);

package/lib/Types/Socket.d.ts

@@ -75,6 +75,8 @@ export type SocketConfig = {
      * map to store the retry counts for failed messages;
      * used to determine whether to retry a message or not */
     msgRetryCounterCache?: CacheStore;
+    /** AunuBaileys: capacity of the built-in sent-message cache used to answer retry receipts when `getMessage` has no copy. Default 256; set 0 to disable. */
+    sentMessagesCacheSize?: number;
     /** provide a cache to store a user's device list */
     userDevicesCache?: CacheStore;
     /** cache to store call offers */

package/lib/Utils/lid-store.d.ts

@@ -0,0 +1,32 @@
+import type { WAMessage } from '../Types/index.js';
+export interface LIDStoreOptions {
+    /** Maximum PN<->LID pairs kept; least-recently-used pairs are evicted. Default 5000. */
+    maxEntries?: number;
+}
+export interface LIDStore {
+    /** Store one PN/LID pair. Returns false when either JID is not a user PN JID / LID JID. */
+    addPair(pnJid: string, lidJid: string): boolean;
+    /** Learn pairs from a message key (senderPn/senderLid, participantPn/participantLid). Returns pairs learned. */
+    learnFromKey(key: Record<string, unknown> | undefined): number;
+    /** Learn pairs from one message. Returns pairs learned. */
+    learnFromMessage(msg: WAMessage | undefined): number;
+    /** Learn pairs from a `messages.upsert` payload. Returns pairs learned. */
+    learnFromUpsert(upsert: { messages?: WAMessage[] }): number;
+    getLIDForPN(pnJid: string): string | undefined;
+    getPNForLID(lidJid: string): string | undefined;
+    hasPN(pnJid: string): boolean;
+    hasLID(lidJid: string): boolean;
+    deletePair(jid: string): boolean;
+    clear(): void;
+    readonly size: number;
+    toJSON(): Record<string, string>;
+    saveToFile(path: string): void;
+    /** Returns the number of pairs loaded; 0 when the file is missing or invalid. */
+    loadFromFile(path: string): number;
+}
+/**
+ * Create a bidirectional PN <-> LID identity store that learns from
+ * live message traffic. Sockets expose an auto-learning instance as
+ * `sock.aunuLid`.
+ */
+export declare const makeLIDStore: (options?: LIDStoreOptions) => LIDStore;

package/lib/Utils/lid-store.js

@@ -0,0 +1,139 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { jidNormalizedUser, isJidUser, isLidUser } from '../WABinary/jid-utils.js';
+/**
+ * AunuBaileys LID identity store.
+ *
+ * WhatsApp is migrating identities from phone-number JIDs
+ * (`<number>@s.whatsapp.net`) to LIDs (`<id>@lid`). Incoming message
+ * stanzas already carry both forms (`sender_pn`/`sender_lid`,
+ * `participant_pn`/`participant_lid`), so this store learns the
+ * PN <-> LID pairs from live traffic and answers bidirectional
+ * lookups locally — no server round-trip, no extra IQ queries.
+ *
+ * The socket attaches an auto-learning instance as `sock.aunuLid`.
+ * A standalone store can also be created with `makeLIDStore()` and
+ * fed manually via `learnFromMessage` / `addPair`.
+ */
+export const makeLIDStore = (options = {}) => {
+    const maxEntries = options.maxEntries ?? 5000;
+    const pnToLid = new Map();
+    const lidToPn = new Map();
+    const touch = (map, key, value) => {
+        // refresh recency for LRU eviction
+        map.delete(key);
+        map.set(key, value);
+    };
+    const evictIfNeeded = () => {
+        while (pnToLid.size > maxEntries) {
+            const oldestPn = pnToLid.keys().next().value;
+            const lid = pnToLid.get(oldestPn);
+            pnToLid.delete(oldestPn);
+            if (lid) {
+                lidToPn.delete(lid);
+            }
+        }
+    };
+    const addPair = (pnJid, lidJid) => {
+        if (!pnJid || !lidJid) {
+            return false;
+        }
+        const pn = jidNormalizedUser(pnJid);
+        const lid = jidNormalizedUser(lidJid);
+        if (!isJidUser(pn) || !isLidUser(lid)) {
+            return false;
+        }
+        // keep both directions consistent if either side was remapped
+        const prevLid = pnToLid.get(pn);
+        if (prevLid && prevLid !== lid) {
+            lidToPn.delete(prevLid);
+        }
+        const prevPn = lidToPn.get(lid);
+        if (prevPn && prevPn !== pn) {
+            pnToLid.delete(prevPn);
+        }
+        touch(pnToLid, pn, lid);
+        touch(lidToPn, lid, pn);
+        evictIfNeeded();
+        return true;
+    };
+    const learnFromKey = (key) => {
+        if (!key) {
+            return 0;
+        }
+        let learned = 0;
+        if (key.senderPn && key.senderLid) {
+            learned += addPair(key.senderPn, key.senderLid) ? 1 : 0;
+        }
+        if (key.participantPn && key.participantLid) {
+            learned += addPair(key.participantPn, key.participantLid) ? 1 : 0;
+        }
+        // a DM chat partner: remoteJid may be the PN while the stanza
+        // only carried the sender LID (or the reverse)
+        if (key.remoteJid && key.senderLid && isJidUser(key.remoteJid) && !key.fromMe) {
+            learned += addPair(key.remoteJid, key.senderLid) ? 1 : 0;
+        }
+        return learned;
+    };
+    const learnFromMessage = (msg) => learnFromKey(msg?.key);
+    const learnFromUpsert = (upsert) => {
+        let learned = 0;
+        for (const msg of upsert?.messages ?? []) {
+            learned += learnFromMessage(msg);
+        }
+        return learned;
+    };
+    const store = {
+        addPair,
+        learnFromKey,
+        learnFromMessage,
+        learnFromUpsert,
+        getLIDForPN: (pnJid) => (pnJid ? pnToLid.get(jidNormalizedUser(pnJid)) : undefined),
+        getPNForLID: (lidJid) => (lidJid ? lidToPn.get(jidNormalizedUser(lidJid)) : undefined),
+        hasPN: (pnJid) => (pnJid ? pnToLid.has(jidNormalizedUser(pnJid)) : false),
+        hasLID: (lidJid) => (lidJid ? lidToPn.has(jidNormalizedUser(lidJid)) : false),
+        deletePair: (jid) => {
+            if (!jid) {
+                return false;
+            }
+            const norm = jidNormalizedUser(jid);
+            const lid = pnToLid.get(norm);
+            if (lid) {
+                pnToLid.delete(norm);
+                lidToPn.delete(lid);
+                return true;
+            }
+            const pn = lidToPn.get(norm);
+            if (pn) {
+                lidToPn.delete(norm);
+                pnToLid.delete(pn);
+                return true;
+            }
+            return false;
+        },
+        clear: () => {
+            pnToLid.clear();
+            lidToPn.clear();
+        },
+        get size() {
+            return pnToLid.size;
+        },
+        toJSON: () => Object.fromEntries(pnToLid),
+        saveToFile: (path) => {
+            writeFileSync(path, JSON.stringify(Object.fromEntries(pnToLid)));
+        },
+        loadFromFile: (path) => {
+            try {
+                const data = JSON.parse(readFileSync(path, 'utf-8'));
+                let loaded = 0;
+                for (const [pn, lid] of Object.entries(data)) {
+                    loaded += addPair(pn, lid) ? 1 : 0;
+                }
+                return loaded;
+            }
+            catch {
+                return 0;
+            }
+        }
+    };
+    return store;
+};

package/lib/Utils/sent-message-cache.d.ts

@@ -0,0 +1,15 @@
+import type { WAMessageContent } from '../Types/index.js';
+export interface SentMessageCache {
+    add(remoteJid: string, id: string, message: WAMessageContent): void;
+    get(remoteJid: string, id: string): WAMessageContent | undefined;
+    readonly size: number;
+    clear(): void;
+}
+/**
+ * Create a bounded FIFO cache of recently relayed message contents,
+ * used to answer retry receipts when the app's `getMessage` store
+ * has no copy. Default capacity 256.
+ */
+export declare const makeSentMessageCache: (maxEntries?: number) => SentMessageCache;
+/** Returns the per-socket cache bound to a socket config object (internal plumbing, also handy in tests). */
+export declare const sentMessageCacheFor: (config: object) => SentMessageCache;

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

@@ -0,0 +1,59 @@
+/**
+ * AunuBaileys sent-message cache for retry receipts.
+ *
+ * When a peer cannot decrypt a message we sent, WhatsApp asks for a
+ * resend via a retry receipt. Upstream Baileys can only answer when
+ * the app supplied a `getMessage` store; with the default
+ * `getMessage: async () => undefined` every retry dies with
+ * "message not available" and the peer never receives the message
+ * (the classic "read but never delivered / stuck unreadable" bug).
+ *
+ * This cache keeps the last N relayed message contents per socket
+ * (whatsmeow-style, default 256) so `sendMessagesAgain` can fall
+ * back to it when the app's own `getMessage` has nothing. The app's
+ * store always wins; this is only a fallback. Set
+ * `sentMessagesCacheSize: 0` in the socket config to disable.
+ */
+export const makeSentMessageCache = (maxEntries = 256) => {
+    const cache = new Map();
+    const keyOf = (remoteJid, id) => `${remoteJid}:${id}`;
+    return {
+        add: (remoteJid, id, message) => {
+            if (!remoteJid || !id || !message || maxEntries <= 0) {
+                return;
+            }
+            const key = keyOf(remoteJid, id);
+            cache.delete(key);
+            cache.set(key, message);
+            while (cache.size > maxEntries) {
+                cache.delete(cache.keys().next().value);
+            }
+        },
+        get: (remoteJid, id) => {
+            if (!remoteJid || !id) {
+                return undefined;
+            }
+            return cache.get(keyOf(remoteJid, id));
+        },
+        get size() {
+            return cache.size;
+        },
+        clear: () => cache.clear()
+    };
+};
+const cachesByConfig = new WeakMap();
+/**
+ * Returns the per-socket sent-message cache bound to a socket
+ * config object. Send and receive layers of the same socket share
+ * one config object, so a WeakMap keyed by it gives every socket
+ * its own isolated cache without any extra plumbing.
+ */
+export const sentMessageCacheFor = (config) => {
+    let cache = cachesByConfig.get(config);
+    if (!cache) {
+        const size = typeof config?.sentMessagesCacheSize === 'number' ? config.sentMessagesCacheSize : 256;
+        cache = makeSentMessageCache(size);
+        cachesByConfig.set(config, cache);
+    }
+    return cache;
+};

package/lib/index.d.ts

@@ -15,3 +15,6 @@ export { processedMessages, initInMemoryKeyStore } from './Utils/fork-compat.js'
 export { PHONENUMBER_MCC } from './Utils/phonenumber-mcc.js';
 export * from './Utils/aunu-handler';
 export * from './Utils/builders';
+export * from './Utils/antiban';
+export * from './Utils/lid-store.js';
+export * from './Utils/sent-message-cache.js';

package/lib/index.js

@@ -14,3 +14,6 @@ export { processedMessages, initInMemoryKeyStore } from './Utils/fork-compat.js'
 export { PHONENUMBER_MCC } from './Utils/phonenumber-mcc.js';
 export * from './Utils/aunu-handler.js';
 export * from './Utils/builders.js';
+export * from './Utils/antiban.js';
+export * from './Utils/lid-store.js';
+export * from './Utils/sent-message-cache.js';

package/package.json

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