@violetix/baileys 0.5.6 → 0.6.0

package/lib/Socket/socket.js

@@ -6,9 +6,7 @@ import { proto } from '../../WAProto/index.js';
 import { DEF_CALLBACK_PREFIX, DEF_TAG_PREFIX, INITIAL_PREKEY_COUNT, MIN_PREKEY_COUNT, NOISE_WA_HEADER, PROCESSABLE_HISTORY_TYPES, TimeMs, UPLOAD_TIMEOUT } from '../Defaults/index.js';
 import { QueryIds, ReachoutTimelockEnforcementType } from '../Types/index.js';
 import { DisconnectReason, XWAPaths } from '../Types/index.js';
-import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, buildPairingQRData, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, fetchLatestWaWebVersion, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode, getPairingCodePlatform, invalidPairingCodeChars, makeEventBuffer, makeNoiseHandler, normalizePairingCode, PAIRING_CODE_ALPHABET, promiseTimeout, signedKeyPair, xmppSignedPreKey } from '../Utils/index.js';
-import { ignoredStanzaNeedsAck, makeIgnoreKeyRegistry } from '../Utils/ignore-key.js';
-import { buildAckStanza } from '../Utils/stanza-ack.js';
+import { addTransactionCapability, aesEncryptCTR, bindWaitForConnectionUpdate, buildPairingQRData, bytesToCrockford, configureSuccessfulPairing, Curve, derivePairingCodeKey, generateLoginNode, generateMdTagPrefix, generateRegistrationNode, getCodeFromWSError, getErrorCodeFromStreamError, getNextPreKeysNode, getPairingCodePlatform, invalidPairingCodeChars, makeEventBuffer, makeNoiseHandler, normalizePairingCode, PAIRING_CODE_ALPHABET, promiseTimeout, signedKeyPair, xmppSignedPreKey } from '../Utils/index.js';
 import { assertNodeErrorFree, binaryNodeToString, encodeBinaryNode, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildren, isLidUser, jidDecode, jidEncode, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { BinaryInfo } from '../WAM/BinaryInfo.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
@@ -21,23 +19,6 @@ import { executeWMexQuery } from './mex.js';
  * - listen to messages and emit events
  * - query phone connection
  */
-/**
- * Version the server accepted after it rejected the configured one with 405 (client_too_old).
- * Process-wide on purpose: every socket built afterwards with a static `version` reuses it,
- * so a stale hardcoded version heals on the next reconnect instead of looping on 405.
- */
-let latestVersionOverride;
-/**
- * Reasons that end a session for good. Reconnecting any of these is how an unattended host turns
- * one logout into an auth loop and gets the number banned.
- */
-const DEAD_DISCONNECT_REASONS = new Set([
-    DisconnectReason.loggedOut,
-    DisconnectReason.forbidden,
-    DisconnectReason.multideviceMismatch,
-    DisconnectReason.badSession,
-    DisconnectReason.connectionReplaced
-]);
 export const makeSocket = (config) => {
     const { waWebSocketUrl, connectTimeoutMs, logger, keepAliveIntervalMs, keepAliveGracePeriodMs, browser, auth: authState, printQRInTerminal, defaultQueryTimeoutMs, transactionOpts, qrTimeout, makeSignalRepository } = config;
     const publicWAMBuffer = new BinaryInfo();
@@ -63,9 +44,9 @@ export const makeSocket = (config) => {
         url.searchParams.append('ED', authState.creds.routingInfo.toString('base64url'));
     }
     /** ephemeral key pair used to encrypt/decrypt communication. Unique for each connection */
-    let ephemeralKeyPair = Curve.generateKeyPair();
+    const ephemeralKeyPair = Curve.generateKeyPair();
     /** WA noise protocol wrapper */
-    let noise = makeNoiseHandler({
+    const noise = makeNoiseHandler({
         keyPair: ephemeralKeyPair,
         NOISE_HEADER: NOISE_WA_HEADER,
         logger,
@@ -147,13 +128,12 @@ export const makeSocket = (config) => {
             node.attrs.id = generateMessageTag();
         }
         const msgId = node.attrs.id;
-        pendingQueries++;
         const result = await promiseTimeout(timeoutMs, async (resolve, reject) => {
             const result = waitForMessage(msgId, timeoutMs).catch(reject);
             sendNode(node)
                 .then(async () => resolve(await result))
                 .catch(reject);
-        }).finally(() => { pendingQueries--; });
+        });
         if (result && 'tag' in result) {
             assertNodeErrorFree(result);
         }
@@ -271,8 +251,7 @@ export const makeSocket = (config) => {
      * where usernameKey is the PIN protecting the username.
      */
     const onWhatsAppUsername = async (...queries) => {
-        // username users are LID-only; ask for LID addressing like WA Web does
-        const usyncQuery = new USyncQuery().withContactProtocol('lid').withUsernameProtocol().withBusinessProtocol(null);
+        const usyncQuery = new USyncQuery().withContactProtocol().withUsernameProtocol();
         const normalized = [];
         for (const query of queries) {
             const raw = typeof query === 'string' ? query : query?.username;
@@ -302,10 +281,7 @@ export const makeSocket = (config) => {
         return results.list.map((result, index) => ({
             username: typeof result.username === 'string' ? result.username : normalized[index] || '',
             jid: result.id,
-            exists: result.contact === true || result.keyRequired === true,
-            keyRequired: result.keyRequired === true,
-            isBusiness: !!result.business,
-            pnJid: result.business?.pnJid || undefined
+            exists: result.contact === true
         }));
     };
     /** fetch the @username of one or more jids, if they have one set */
@@ -384,34 +360,14 @@ export const makeSocket = (config) => {
     };
     const ev = makeEventBuffer(logger);
     const { creds } = authState;
-    /**
-     * Last identity this socket has been logged in as. `sock.user` is a getter over
-     * `authState.creds.me`, and hosts read it as `sock.user.id` with no optional chaining (the
-     * @neoxr/wb engine does exactly that in serialize() and in its JID() helper). One stanza that
-     * arrives while `creds.me` is momentarily absent therefore throws inside the host's event
-     * listener instead of being processed. Keeping the identity we already know turns that into a
-     * correct answer: a socket that is receiving stanzas is logged in as this user.
-     */
-    // A copy, and only when it carries an id: `creds.me` is replaced wholesale by some updates (a
-    // `CB:success` or a pushName change can arrive with a lid-only object), and holding the same
-    // reference would follow that replacement into the fallback.
-    let lastMe = creds.me?.id ? { ...creds.me } : undefined;
-    let userMissingLogged = false;
     // add transaction capability
     const keys = addTransactionCapability(authState.keys, logger, transactionOpts);
     const signalRepository = makeSignalRepository({ creds, keys }, logger, pnFromLIDUSync);
     let lastDateRecv;
-    /** queries awaiting a reply; keep-alive skips its ping while these are flowing */
-    let pendingQueries = 0;
     let epoch = 1;
     let keepAliveReq;
     let qrTimer;
     let closed = false;
-    /** transparent transport reconnect state; see scheduleReconnect */
-    let reconnecting = false;
-    let reconnectAttempts = 0;
-    let reconnectTimer;
-    let reconnectWaitResolve;
     /** set once WhatsApp sends pair-device; requestPairingCode queues until then */
     let pairingReady = false;
     let pairingInProgress = false;
@@ -420,8 +376,6 @@ export const makeSocket = (config) => {
     let pendingPairingResolve;
     let pendingPairingReject;
     const socketEndHandlers = [];
-    /** per-connection caches (media host auth, ...) that must be dropped when the transport reopens */
-    const socketReconnectHandlers = [];
     const timers = new Set();
     const safeSetTimeout = (fn, ms) => { const id = setTimeout(fn, ms); timers.add(id); return id; };
     const safeSetInterval = (fn, ms) => { const id = setInterval(fn, ms); timers.add(id); return id; };
@@ -468,19 +422,13 @@ export const makeSocket = (config) => {
         const handshake = proto.HandshakeMessage.decode(result);
         logger.trace({ handshake }, 'handshake recv from WA');
         const keyEnc = noise.processHandshake(handshake, creds.noiseKey);
-        // `version` may be a resolver (e.g. () => fetchLatestWaWebVersion().then(r => r.version));
-        // a version the server already rejected as too old is replaced by the fetched one
-        const resolvedVersion = typeof config.version === 'function'
-            ? await config.version()
-            : latestVersionOverride ?? config.version;
-        const connectConfig = resolvedVersion === config.version ? config : { ...config, version: resolvedVersion };
         let node;
         if (!creds.me) {
-            node = generateRegistrationNode(creds, connectConfig);
+            node = generateRegistrationNode(creds, config);
             logger.info({ node }, 'not logged in, attempting registration...');
         }
         else {
-            node = generateLoginNode(creds.me.id, connectConfig);
+            node = generateLoginNode(creds.me.id, config);
             logger.info({ node }, 'logging in...');
         }
         const payloadEnc = noise.encrypt(proto.ClientPayload.encode(node).finish());
@@ -596,11 +544,6 @@ export const makeSocket = (config) => {
             // Don't throw - allow connection to continue even if pre-key check fails
         }
     };
-    const ignoreKeyRegistry = makeIgnoreKeyRegistry({
-        getMeId: () => authState.creds.me?.id,
-        getMeLid: () => authState.creds.me?.lid,
-        logger
-    });
     const onMessageReceived = async (data) => {
         await noise.decodeFrame(data, frame => {
             lastDateRecv = new Date();
@@ -611,16 +554,6 @@ export const makeSocket = (config) => {
                 if (logger.level === 'trace') {
                     logger.trace({ xml: binaryNodeToString(frame), msg: 'recv xml' });
                 }
-                // Filters run before every other handler, so a dropped stanza never reaches the
-                // decryption or persistence paths. The ack still goes out, otherwise the server
-                // keeps re-delivering what the host just asked to ignore.
-                if (ignoreKeyRegistry.shouldDrop(frame)) {
-                    logger.debug({ tag: frame.tag, id: msgId, from: frame.attrs.from }, 'stanza dropped by ignoreKey');
-                    if (ignoredStanzaNeedsAck(frame.tag)) {
-                        sendNode(buildAckStanza(frame, undefined, authState.creds.me?.id)).catch(err => logger.error({ err, id: msgId }, 'failed to ack ignored stanza'));
-                    }
-                    return;
-                }
                 anyTriggered = ws.emit(`${DEF_TAG_PREFIX}${msgId}`, frame) || anyTriggered;
                 const l0 = frame.tag;
                 const l1 = frame.attrs || {};
@@ -645,24 +578,6 @@ export const makeSocket = (config) => {
             return;
         }
         closed = true;
-        // Name the disconnect reason in the message itself. The code was always on `error.output`,
-        // but a host does not always receive the Boom: a wrapper that re-emits this close as its own
-        // `error` event forwards `message` and nothing else, and the messages alone cannot be told
-        // apart — `CB:failure` says the constant 'Connection Failure' for a 401 device-removal and
-        // for a transient 503 alike. A host that cannot distinguish them keeps reconnecting a
-        // session that is really gone, which is how an unattended fleet turns one logout into a
-        // re-auth loop and gets the number banned.
-        //
-        // Done here rather than at each `end()` call site because there are a dozen of them and a
-        // new one would silently miss it. The existing text is kept as a prefix, so message matching
-        // that already works keeps working; the suffix is additive.
-        const statusCode = error?.output?.statusCode;
-        if (statusCode !== undefined && typeof error?.message === 'string' && !error.message.includes(`[${statusCode} `)) {
-            try {
-                error.message = `${error.message} [${statusCode} ${DisconnectReason[statusCode] || 'unknown'}]`;
-            }
-            catch { }
-        }
         logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
         // Signal-key writes are debounced (addTransactionCapability). Nothing else in the library
         // called flush, so every ratchet advance from the last window was dropped on close and the
@@ -681,9 +596,6 @@ export const makeSocket = (config) => {
             keepAliveReq?.cancel();
             clearSafeTimer(qrTimer);
             clearAllTimers();
-            // release a pending reconnect wait so scheduleReconnect cannot stay suspended
-            reconnectWaitResolve?.();
-            reconnectWaitResolve = undefined;
             // a queued requestPairingCode would hang forever otherwise
             pairingReady = false;
             pairingInProgress = false;
@@ -727,90 +639,6 @@ export const makeSocket = (config) => {
             logger.error({ err }, 'error while closing connection');
         }
     };
-    /** rebuild the state that belongs to one transport connection, not to the socket object */
-    const resetTransport = () => {
-        keepAliveReq?.cancel();
-        keepAliveReq = undefined;
-        clearSafeTimer(qrTimer);
-        qrTimer = undefined;
-        lastDateRecv = undefined;
-        ephemeralKeyPair = Curve.generateKeyPair();
-        noise = makeNoiseHandler({
-            keyPair: ephemeralKeyPair,
-            NOISE_HEADER: NOISE_WA_HEADER,
-            logger,
-            routingInfo: authState?.creds?.routingInfo
-        });
-        // the media host token is issued per connection; a cached one fails every upload after this
-        for (const handler of socketReconnectHandlers) {
-            try {
-                handler();
-            }
-            catch (err) {
-                logger.error({ err }, 'error in socket reconnect handler');
-            }
-        }
-    };
-    /**
-     * Transparent reconnect. The WebSocket client object is kept and only the raw socket and the
-     * noise session under it are replaced, so every stanza listener registered by the layers above
-     * (messages-recv, chats, the host) keeps working and the host never sees a `close` for a drop
-     * that this socket can repair itself.
-     */
-    const scheduleReconnect = async (error) => {
-        if (reconnecting || closed) {
-            return;
-        }
-        reconnecting = true;
-        const statusCode = error?.output?.statusCode;
-        const maxAttempts = config.maxReconnectAttempts ?? 10;
-        if (!config.autoReconnect || DEAD_DISCONNECT_REASONS.has(statusCode) || reconnectAttempts >= maxAttempts) {
-            reconnecting = false;
-            return end(error);
-        }
-        reconnectAttempts += 1;
-        // 515 means the server wants the connection back now; backing off only delays it
-        const immediate = statusCode === DisconnectReason.restartRequired;
-        const base = config.reconnectDelayMs ?? 2000;
-        const ceiling = config.maxReconnectDelayMs ?? 60000;
-        const backoff = Math.min(ceiling, base * 2 ** (reconnectAttempts - 1));
-        // jitter keeps a fleet from reconnecting in lockstep after a server-side blip
-        const delayMs = immediate ? 0 : Math.round(backoff * (0.75 + Math.random() * 0.5));
-        logger.info({ statusCode, attempt: reconnectAttempts, delayMs }, 'connection lost, reconnecting');
-        // NOT 'close': a host reads close as "build a new socket", and a second socket for the same
-        // account is what earns a 440 connectionReplaced
-        ev.emit('connection.update', {
-            connection: 'connecting',
-            lastDisconnect: { error, date: new Date() }
-        });
-        await new Promise(resolve => {
-            reconnectWaitResolve = resolve;
-            reconnectTimer = safeSetTimeout(() => {
-                reconnectWaitResolve = undefined;
-                resolve();
-            }, delayMs);
-        });
-        reconnectTimer = undefined;
-        reconnecting = false;
-        if (closed) {
-            return;
-        }
-        try {
-            resetTransport();
-            ws.reconnect();
-        }
-        catch (err) {
-            logger.error({ err }, 'failed to reopen the transport');
-            return end(err);
-        }
-    };
-    /** single entry point for every transport-level close */
-    const handleDisconnect = (error) => {
-        if (closed) {
-            return;
-        }
-        return scheduleReconnect(error);
-    };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
             return;
@@ -832,89 +660,48 @@ export const makeSocket = (config) => {
             ws.off('error', onClose);
         });
     };
-    /**
-     * Keep-alive, modelled on zapo-js (src/transport/keepalive/WaKeepAlive.ts):
-     * - self-rescheduling setTimeout with +-10% jitter (min 250ms), so a fleet of sockets in one
-     *   process drifts apart instead of pinging in the same tick
-     * - at most one ping in flight; a slow pong never stacks more pings on a busy loop
-     * - no ping while other queries are pending and data arrived recently: the link is
-     *   demonstrably alive and the ping would only add queue pressure
-     * - "lost" is still decided by inbound silence (interval + grace), and skipped when the
-     *   timer itself fired late (blocked event loop: pongs may be unread in the socket buffer)
-     */
     const startKeepAliveRequest = () => {
-        let timer;
-        let stopped = false;
-        let pingInFlight = false;
-        let lastCheckAt;
-        let expectedDelayMs = 0;
-        const nextDelay = () => {
-            const jitter = Math.max(250, Math.floor(keepAliveIntervalMs * 0.1));
-            return Math.max(1000, keepAliveIntervalMs + Math.floor((Math.random() * 2 - 1) * jitter));
-        };
-        const schedule = (delayMs) => {
-            if (stopped) {
-                return;
-            }
-            expectedDelayMs = delayMs;
-            timer = safeSetTimeout(() => {
-                timer = undefined;
-                cb();
-                schedule(nextDelay());
-            }, delayMs);
-        };
         const cb = () => {
             if (!lastDateRecv) {
                 lastDateRecv = new Date();
             }
-            const now = Date.now();
-            const sinceRecvMs = now - lastDateRecv.getTime();
-            const lagMs = lastCheckAt ? now - lastCheckAt - expectedDelayMs : 0;
-            lastCheckAt = now;
-            const loopStalled = lagMs > keepAliveGracePeriodMs;
-            if (loopStalled) {
-                logger.warn({ lagMs, sinceLastRecvMs: sinceRecvMs }, 'event loop stalled; deferring keep-alive timeout');
+            const diff = Date.now() - lastDateRecv.getTime();
+            if (diff > keepAliveIntervalMs + keepAliveGracePeriodMs) {
+                void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
             }
-            if (sinceRecvMs > keepAliveIntervalMs + keepAliveGracePeriodMs && !loopStalled) {
-                void handleDisconnect(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
-                return;
+            else if (ws.isOpen) {
+                query({
+                    tag: 'iq',
+                    attrs: {
+                        id: generateMessageTag(),
+                        to: S_WHATSAPP_NET,
+                        type: 'get',
+                        xmlns: 'w:p'
+                    },
+                    content: [{ tag: 'ping', attrs: {} }]
+                }).catch(err => {
+                    logger.error({ trace: err.stack }, 'error in sending keep alive');
+                });
             }
-            if (!ws.isOpen) {
+            else {
                 logger.warn('keep alive called when WS not open');
-                return;
-            }
-            if (pingInFlight) {
-                logger.trace('keep alive skipped: ping already in flight');
-                return;
-            }
-            if (pendingQueries > 0 && sinceRecvMs < keepAliveGracePeriodMs) {
-                logger.trace({ pendingQueries, sinceRecvMs }, 'keep alive skipped: queries pending with recent inbound');
-                return;
             }
-            pingInFlight = true;
-            query({
-                tag: 'iq',
-                attrs: {
-                    id: generateMessageTag(),
-                    to: S_WHATSAPP_NET,
-                    type: 'get',
-                    xmlns: 'w:p'
-                },
-                content: [{ tag: 'ping', attrs: {} }]
-            }, keepAliveIntervalMs + keepAliveGracePeriodMs)
-                .catch(err => {
-                    // the verdict stays with inbound silence above; a failed ping alone is not "lost"
-                    logger.warn({ trace: err.stack }, 'error in sending keep alive');
-                })
-                .finally(() => { pingInFlight = false; });
         };
-        // random first tick staggers sockets that connect together (reconnect storms)
-        schedule(Math.floor(Math.random() * (keepAliveIntervalMs / 2)));
+        // Per socket, so keepAliveIntervalMs from the config is actually the ping interval: the
+        // shared process-wide timer ran at a hardcoded 30s while the staleness check below still
+        // used the configured value, so any interval other than 30s produced false connectionLost.
+        // The random start offset staggers the fleet - on the shared timer every socket in the
+        // process pinged in the same tick, which is a self-inflicted burst at 100+ sessions.
+        let pinger;
+        const starter = safeSetTimeout(() => {
+            cb();
+            pinger = safeSetInterval(cb, keepAliveIntervalMs);
+        }, Math.floor(Math.random() * (keepAliveIntervalMs / 2)));
         keepAliveReq = {
             cb,
             cancel: () => {
-                stopped = true;
-                clearSafeTimer(timer);
+                clearSafeTimer(starter);
+                clearSafeTimer(pinger);
             }
         };
     };
@@ -1027,14 +814,14 @@ export const makeSocket = (config) => {
         if (customPairingCode && customPairingCode.length !== 8) {
             throw new Error('Custom pairing code must be exactly 8 chars');
         }
-        // WhatsApp Web rejects these characters up front: the phone normalizes 0/I/O/U before it
-        // derives its key, so a code containing them fails on the phone ("Couldn't link device")
-        // with nothing on the wire. Fail here instead, where the caller can see it.
+        // Not fatal, because whether WhatsApp normalizes these characters is not observable from
+        // here - but it is the one thing that fails silently on the phone rather than on the wire,
+        // so it gets named in the log instead of being guessed at during the next outage.
         const wantedCode = customPairingCode ? normalizePairingCode(customPairingCode) : undefined;
         if (wantedCode) {
             const invalid = invalidPairingCodeChars(wantedCode);
             if (invalid.length) {
-                throw new Boom(`Custom pairing code "${wantedCode}" contains characters WhatsApp does not accept (${invalid.join(', ')}); allowed: ${PAIRING_CODE_ALPHABET}`, { statusCode: 400, data: { pairingCode: wantedCode, invalid } });
+                logger.warn({ pairingCode: wantedCode, invalid, allowed: PAIRING_CODE_ALPHABET }, 'custom pairing code uses characters absent from WhatsApp\'s own alphabet; if linking fails with "Couldn\'t link device", try a code built only from the allowed characters');
             }
         }
         if (pairingInProgress) {
@@ -1106,13 +893,13 @@ export const makeSocket = (config) => {
         }
         catch (err) {
             logger.error({ err }, 'error in validating connection');
-            void handleDisconnect(err);
+            void end(err);
         }
     });
-    ws.on('error', mapWebSocketError(handleDisconnect));
-    ws.on('close', () => void handleDisconnect(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('error', mapWebSocketError(end));
+    ws.on('close', () => void end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
     // the server terminated the connection
-    ws.on('CB:xmlstreamend', () => void handleDisconnect(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('CB:xmlstreamend', () => void end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
     // QR gen
     ws.on('CB:iq,type:set,pair-device', async (stanza) => {
         const iq = {
@@ -1177,9 +964,6 @@ export const makeSocket = (config) => {
     });
     // login complete
     ws.on('CB:success', async (node) => {
-        // a completed handshake clears the reconnect budget: the next drop starts from the base delay
-        reconnectAttempts = 0;
-        reconnecting = false;
         try {
             updateServerTimeOffset(node);
             await uploadPreKeysToServerIfRequired();
@@ -1198,11 +982,6 @@ export const makeSocket = (config) => {
         logger.info('opened connection to WA');
         clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
         ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } });
-        if (!authState.creds.me?.id) {
-            // `me` absent: the spread above produced a lid-only identity, which hosts then read as
-            // `sock.user.id === undefined`. Say so once per socket instead of letting it look healthy.
-            logger.error({ credsKeys: Object.keys(authState.creds), registered: authState.creds.registered, hasAccount: !!authState.creds.account }, 'login completed but creds.me.id is missing — host reads sock.user.id unguarded');
-        }
         ev.emit('connection.update', { connection: 'open' });
         void sendUnifiedSession();
         if (node.attrs.lid && authState.creds.me?.id) {
@@ -1233,62 +1012,23 @@ export const makeSocket = (config) => {
         const [reasonNode] = getAllBinaryNodeChildren(node);
         logger.error({ reasonNode, fullErrorNode: node }, 'stream errored out');
         const { reason, statusCode } = getErrorCodeFromStreamError(node);
-        void handleDisconnect(new Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
+        void end(new Boom(`Stream Errored (${reason})`, { statusCode, data: reasonNode || node }));
     });
     // stream fail, possible logout
-    ws.on('CB:failure', async (node) => {
+    ws.on('CB:failure', (node) => {
         const reason = +(node.attrs.reason || 500);
-        if (reason === 405 && typeof config.version !== 'function') {
-            // client_too_old: fetch the live WA Web build so the caller's reconnect uses it
-            const latest = await fetchLatestWaWebVersion({});
-            if (latest.isLatest) {
-                latestVersionOverride = latest.version;
-                logger.warn({ rejected: latestVersionOverride === config.version ? undefined : config.version, latest: latest.version }, 'server rejected the client version as too old (405); the next connection uses the latest WA Web version');
-            }
-            else {
-                logger.warn({ err: latest.error?.message }, 'server rejected the client version as too old (405) and the latest version could not be fetched; pass a current `version`');
-            }
-        }
-        void handleDisconnect(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
+        void end(new Boom('Connection Failure', { statusCode: reason, data: node.attrs }));
     });
     ws.on('CB:ib,,downgrade_webclient', () => {
-        void handleDisconnect(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
+        void end(new Boom('Multi-device beta not joined', { statusCode: DisconnectReason.multideviceMismatch }));
     });
-    // The server delivers the offline queue in windows and waits for another <offline_batch/>
-    // before sending the next one. A single request only drained the first 100 stanzas, so a
-    // larger queue never finished and grew on every reconnect. Request the next window each
-    // time a queued stanza (attrs.offline) arrives, debounced so a burst yields one request.
-    // ponytail: no stanza timeout; the terminal 'offline' bulletin ends the loop.
-    let offlineResuming = false;
-    let offlineBatchInFlight = false;
-    let offlineBatchTimer;
-    const requestOfflineBatch = () => {
-        if (!offlineResuming || offlineBatchInFlight) {
-            return;
-        }
-        offlineBatchInFlight = true;
-        sendNode({
+    ws.on('CB:ib,,offline_preview', async (node) => {
+        logger.info('offline preview received', JSON.stringify(node));
+        await sendNode({
             tag: 'ib',
             attrs: {},
             content: [{ tag: 'offline_batch', attrs: { count: '100' } }]
-        }).catch(err => {
-            offlineBatchInFlight = false;
-            logger.debug({ err }, 'offline batch request failed');
         });
-    };
-    ws.on('CB:ib,,offline_preview', (node) => {
-        logger.info('offline preview received', JSON.stringify(node));
-        offlineResuming = true;
-        offlineBatchInFlight = false;
-        requestOfflineBatch();
-    });
-    ws.on('frame', (frame) => {
-        if (!offlineResuming || frame instanceof Uint8Array || frame.attrs?.offline === undefined) {
-            return;
-        }
-        offlineBatchInFlight = false;
-        clearTimeout(offlineBatchTimer);
-        offlineBatchTimer = setTimeout(requestOfflineBatch, 100);
     });
     ws.on('CB:ib,,edge_routing', (node) => {
         const edgeRoutingNode = getBinaryNodeChild(node, 'edge_routing');
@@ -1310,8 +1050,6 @@ export const makeSocket = (config) => {
     });
     // called when all offline notifs are handled
     ws.on('CB:ib,,offline', (node) => {
-        offlineResuming = false;
-        clearTimeout(offlineBatchTimer);
         const child = getBinaryNodeChild(node, 'offline');
         const offlineNotifs = +(child?.attrs.count || 0);
         logger.info(`handled ${offlineNotifs} offline messages/notifications`);
@@ -1335,9 +1073,6 @@ export const makeSocket = (config) => {
             });
         }
         Object.assign(creds, update);
-        if (creds.me?.id) {
-            lastMe = { ...creds.me };
-        }
     });
     const updateServerTimeOffset = ({ attrs }) => {
         const tValue = attrs?.t;
@@ -1384,9 +1119,6 @@ export const makeSocket = (config) => {
     const registerSocketEndHandler = (handler) => {
         socketEndHandlers.push(handler);
     };
-    const registerSocketReconnectHandler = (handler) => {
-        socketReconnectHandlers.push(handler);
-    };
     /**
      * Fetches your account's standing when it comes to restrictions.
      * @returns Returns the state of the restrictions.
@@ -1417,33 +1149,9 @@ export const makeSocket = (config) => {
         authState: { creds, keys },
         signalRepository,
         get user() {
-            // `.id`, not just presence: a lid-only `me` is truthy and would be handed to hosts that
-            // read `.id` unguarded, which is the crash this fallback exists to prevent.
-            const me = authState.creds.me?.id ? authState.creds.me : lastMe;
-            if (!me && !userMissingLogged) {
-                userMissingLogged = true;
-                logger.error(
-                    {
-                        credsKeys: Object.keys(authState.creds),
-                        registered: authState.creds.registered,
-                        hasAccount: !!authState.creds.account,
-                        sameAuthObject: authState === config.auth
-                    },
-                    'sock.user is undefined: creds.me never arrived on this socket (host reads sock.user.id unguarded)'
-                );
-            }
-            return me;
-        },
-        /**
-         * True while the transport is repairing itself. A host that reads this does not build a
-         * second socket for the same account, which is what a `ws.isOpen === false` check would
-         * make it do during the backoff window and the handshake that follows.
-         */
-        get isReconnecting() {
-            return reconnecting || (reconnectAttempts > 0 && !closed && !ws.isOpen);
+            return authState.creds.me;
         },
         generateMessageTag,
-        ignoreKey: ignoreKeyRegistry.register,
         query,
         waitForMessage,
         waitForSocketOpen,
@@ -1452,7 +1160,6 @@ export const makeSocket = (config) => {
         logout,
         end,
         registerSocketEndHandler,
-        registerSocketReconnectHandler,
         onUnexpectedError,
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,