zapo-js 0.1.1 → 0.2.0

package/dist/esm/client/coordinators/WaRetryCoordinator.js

@@ -1,21 +1,27 @@
 import { proto } from '../../proto.js';
 import { WA_MESSAGE_TAGS } from '../../protocol/constants.js';
-import { isGroupOrBroadcastJid, normalizeDeviceJid, parseSignalAddressFromJid, toUserJid } from '../../protocol/jid.js';
+import { isGroupOrBroadcastJid, normalizeDeviceJid, parseJidFull } from '../../protocol/jid.js';
 import { MAX_RETRY_ATTEMPTS, RETRY_KEYS_MIN_COUNT, RETRY_OUTBOUND_TTL_MS, RETRY_REASON } from '../../retry/constants.js';
-import { pickRetryStateMax } from '../../retry/outbound.js';
-import { parseRetryReceiptRequest } from '../../retry/parse.js';
+import { parseRetryReceiptRequest, pickRetryStateMax } from '../../retry/parse.js';
 import { mapRetryReasonFromError } from '../../retry/reason.js';
 import { WaRetryReplayService } from '../../retry/replay.js';
 import { generatePreKeyPair } from '../../signal/registration/keygen.js';
-import { buildInboundRetryReceiptAckNode } from '../../transport/node/builders/message.js';
+import { buildAckNode } from '../../transport/node/builders/global.js';
 import { buildRetryReceiptNode } from '../../transport/node/builders/retry.js';
+import { uint8Equal } from '../../util/bytes.js';
+import { setBoundedMapEntry } from '../../util/collections.js';
 import { toError } from '../../util/primitives.js';
+const RETRY_CLEANUP_INTERVAL_MS = 30000;
+const RETRY_SESSION_BASE_KEY_CACHE_MAX_ENTRIES = 8192;
 function getRetryReasonName(code) {
     if (code === undefined) {
         return undefined;
     }
-    const entry = Object.entries(RETRY_REASON).find(([, value]) => value === code);
-    return entry ? entry[0] : 'unknown';
+    for (const reasonName in RETRY_REASON) {
+        if (RETRY_REASON[reasonName] === code)
+            return reasonName;
+    }
+    return 'unknown';
 }
 function getRemoteRetryReasonLogFields(reason) {
     return {
@@ -26,6 +32,7 @@ function getRemoteRetryReasonLogFields(reason) {
 }
 export class WaRetryCoordinator {
     constructor(options) {
+        this.nextRetryCleanupAtMs = 0;
         this.logger = options.logger;
         this.retryStore = options.retryStore;
         this.retryTtlMs = this.retryStore.getTtlMs?.() ?? RETRY_OUTBOUND_TTL_MS;
@@ -47,6 +54,7 @@ export class WaRetryCoordinator {
             getCurrentSignedIdentity: this.getCurrentSignedIdentity
         });
         this.retryProcessingByMessageId = new Map();
+        this.retrySessionBaseKeys = new Map();
     }
     async onDecryptFailure(context, error) {
         try {
@@ -71,12 +79,23 @@ export class WaRetryCoordinator {
         if (!this.isRetryReceiptNode(receiptNode)) {
             return;
         }
+        let shouldAck = false;
         try {
-            await this.retryStore.cleanupExpired(Date.now());
-            const request = parseRetryReceiptRequest(receiptNode);
+            await this.maybeCleanupRetryStore(Date.now());
+            const expectedToJids = [];
+            const meJid = this.getCurrentMeJid()?.trim();
+            const meLid = this.getCurrentMeLid()?.trim();
+            if (meJid) {
+                expectedToJids.push(meJid);
+            }
+            if (meLid) {
+                expectedToJids.push(meLid);
+            }
+            const request = parseRetryReceiptRequest(receiptNode, expectedToJids.length > 0 ? { expectedToJids } : undefined);
             if (!request) {
                 return;
             }
+            shouldAck = true;
             await this.handleParsedRetryRequest(receiptNode, request);
         }
         catch (error) {
@@ -88,7 +107,9 @@ export class WaRetryCoordinator {
             });
         }
         finally {
-            await this.sendRetryAckSafe(receiptNode);
+            if (shouldAck) {
+                await this.sendRetryAckSafe(receiptNode);
+            }
         }
     }
     isRetryReceiptNode(node) {
@@ -97,10 +118,7 @@ export class WaRetryCoordinator {
     }
     async prepareDecryptFailureRetry(context, error) {
         const nowMs = Date.now();
-        const [, registrationInfo] = await Promise.all([
-            this.retryStore.cleanupExpired(nowMs),
-            this.signalStore.getRegistrationInfo()
-        ]);
+        const registrationInfo = await this.signalStore.getRegistrationInfo();
         if (!registrationInfo) {
             this.logger.warn('retry receipt skipped: missing local registration info', {
                 id: context.stanzaId,
@@ -127,7 +145,6 @@ export class WaRetryCoordinator {
             to: context.from,
             participant: context.participant,
             recipient: context.recipient,
-            from: this.getCurrentMeJid() ?? undefined,
             originalMsgId: context.stanzaId,
             retryCount: prepared.retryCount,
             t: prepared.timestamp,
@@ -195,6 +212,22 @@ export class WaRetryCoordinator {
             });
             return null;
         }
+        let requesterAddress;
+        let requesterNormalizedDeviceJid;
+        try {
+            const requesterParsed = parseJidFull(requesterJid);
+            requesterAddress = requesterParsed.address;
+            requesterNormalizedDeviceJid = requesterParsed.normalizedJid;
+        }
+        catch (error) {
+            this.logger.info('retry request rejected: invalid requester jid', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: requesterJid,
+                message: toError(error).message
+            });
+            return null;
+        }
         if (request.retryCount >= MAX_RETRY_ATTEMPTS) {
             this.logger.info('retry request rejected: retry count exceeded', {
                 id: request.stanzaId,
@@ -214,7 +247,7 @@ export class WaRetryCoordinator {
             });
             return null;
         }
-        const sessionReady = await this.updateLocalSessionFromRetryRequest(request, requesterJid);
+        const sessionReady = await this.updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!sessionReady) {
             this.logger.info('retry request rejected: missing compatible session', {
                 id: request.stanzaId,
@@ -225,7 +258,7 @@ export class WaRetryCoordinator {
             });
             return null;
         }
-        const authorization = await this.authorizeRetryRequest(request, outbound, requesterJid);
+        const authorization = await this.authorizeRetryRequest(request, outbound, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
         if (!authorization.authorized) {
             this.logger.info('retry request rejected', {
                 id: request.stanzaId,
@@ -239,6 +272,8 @@ export class WaRetryCoordinator {
         }
         return {
             requesterJid,
+            requesterAddress,
+            requesterNormalizedDeviceJid,
             outbound
         };
     }
@@ -258,20 +293,36 @@ export class WaRetryCoordinator {
         if (!nextState) {
             return;
         }
-        const current = await this.retryStore.getOutboundMessage(messageId);
-        if (!current) {
-            return;
-        }
-        const merged = pickRetryStateMax(current.state, nextState);
-        if (merged === current.state) {
-            return;
-        }
-        const nowMs = Date.now();
-        await this.retryStore.updateOutboundMessageState(messageId, merged, nowMs, nowMs + this.retryTtlMs);
+        await this.runRetryTaskSerialized(messageId, async () => {
+            const current = await this.retryStore.getOutboundMessage(messageId);
+            if (!current) {
+                return;
+            }
+            const nowMs = Date.now();
+            const expiresAtMs = nowMs + this.retryTtlMs;
+            const merged = pickRetryStateMax(current.state, nextState);
+            if (merged !== current.state) {
+                await this.retryStore.updateOutboundMessageState(messageId, merged, nowMs, expiresAtMs);
+            }
+            const requesterJid = receiptNode.attrs.participant ?? receiptNode.attrs.from;
+            if (!requesterJid) {
+                return;
+            }
+            try {
+                await this.retryStore.markOutboundRequesterDelivered(messageId, normalizeDeviceJid(requesterJid), nowMs, expiresAtMs);
+            }
+            catch (error) {
+                this.logger.warn('failed to update outbound requester delivery state', {
+                    id: messageId,
+                    requester: requesterJid,
+                    message: toError(error).message
+                });
+            }
+        });
     }
     async runRetryTaskSerialized(messageId, task) {
         const previous = this.retryProcessingByMessageId.get(messageId) ?? Promise.resolve();
-        const current = previous.catch(() => undefined).then(async () => task());
+        const current = previous.then(task);
         const tracker = current.then(() => undefined, () => undefined);
         this.retryProcessingByMessageId.set(messageId, tracker);
         try {
@@ -311,18 +362,47 @@ export class WaRetryCoordinator {
                 : undefined
         };
     }
-    async updateLocalSessionFromRetryRequest(request, requesterJid) {
-        await this.markRetryRequesterSenderKeyAsStale(request, requesterJid);
-        const address = parseSignalAddressFromJid(requesterJid);
-        const currentSession = await this.signalStore.getSession(address);
-        if (currentSession && request.regId > 0 && currentSession.remote.regId !== request.regId) {
-            await this.signalStore.deleteSession(address);
+    async updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
+        const [, currentSession] = await Promise.all([
+            this.markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress),
+            this.signalStore.getSession(requesterAddress)
+        ]);
+        const regIdMismatch = !!currentSession && request.regId > 0 && currentSession.remote.regId !== request.regId;
+        if (regIdMismatch && !request.keyBundle) {
+            await this.signalStore.deleteSession(requesterAddress);
         }
         if (request.keyBundle) {
-            if (!request.keyBundle.key) {
+            if (!request.keyBundle.key || !request.keyBundle.skey.signature) {
                 return false;
             }
-            await this.signalProtocol.establishOutgoingSession(address, {
+            if (request.offline) {
+                if (!currentSession) {
+                    this.logger.info('retry request rejected: offline retry missing existing session', {
+                        id: request.stanzaId,
+                        originalMsgId: request.originalMsgId,
+                        requester: requesterJid,
+                        remoteRetryCount: request.retryCount,
+                        ...getRemoteRetryReasonLogFields(request.retryReason)
+                    });
+                    await this.signalStore.deleteSession(requesterAddress);
+                    return false;
+                }
+                if (regIdMismatch) {
+                    this.logger.info('retry request rejected: offline retry registration id mismatch', {
+                        id: request.stanzaId,
+                        originalMsgId: request.originalMsgId,
+                        requester: requesterJid,
+                        remoteRetryCount: request.retryCount,
+                        ...getRemoteRetryReasonLogFields(request.retryReason)
+                    });
+                    await this.signalStore.deleteSession(requesterAddress);
+                    return false;
+                }
+            }
+            else if (regIdMismatch) {
+                await this.signalStore.deleteSession(requesterAddress);
+            }
+            await this.signalProtocol.establishOutgoingSession(requesterAddress, {
                 regId: request.regId,
                 identity: request.keyBundle.identity,
                 signedKey: {
@@ -335,25 +415,57 @@ export class WaRetryCoordinator {
                     publicKey: request.keyBundle.key.publicKey
                 }
             });
+            return this.applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
+        }
+        const sessionStillExists = currentSession !== null && !regIdMismatch;
+        if (sessionStillExists) {
+            return this.applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
+        }
+        const fetched = await this.fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, request.regId);
+        if (!fetched) {
+            return false;
+        }
+        await this.signalProtocol.establishOutgoingSession(requesterAddress, fetched);
+        return this.applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid);
+    }
+    async applySessionBaseKeyPolicy(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
+        if (request.retryCount < 2) {
+            return true;
+        }
+        const currentSession = await this.signalStore.getSession(requesterAddress);
+        const sessionBaseKey = currentSession?.aliceBaseKey ?? null;
+        if (!sessionBaseKey) {
             return true;
         }
-        const hasSession = await this.signalProtocol.hasSession(address);
-        if (hasSession) {
+        const expiresAtMs = Date.now() + this.retryTtlMs;
+        if (request.retryCount === 2) {
+            this.setRetrySessionBaseKey(request.originalMsgId, requesterNormalizedDeviceJid, sessionBaseKey, expiresAtMs);
             return true;
         }
-        const fetched = await this.fetchMissingPreKeysSession(requesterJid, request.regId);
+        const saved = this.getRetrySessionBaseKey(request.originalMsgId, requesterNormalizedDeviceJid);
+        if (!saved || !uint8Equal(saved.baseKey, sessionBaseKey)) {
+            return true;
+        }
+        await this.signalStore.deleteSession(requesterAddress);
+        this.logger.info('retry request forcing session refresh due to repeated base key', {
+            id: request.stanzaId,
+            originalMsgId: request.originalMsgId,
+            requester: requesterJid,
+            remoteRetryCount: request.retryCount,
+            ...getRemoteRetryReasonLogFields(request.retryReason)
+        });
+        const fetched = await this.fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, request.regId);
         if (!fetched) {
             return false;
         }
-        await this.signalProtocol.establishOutgoingSession(address, fetched);
+        await this.signalProtocol.establishOutgoingSession(requesterAddress, fetched);
         return true;
     }
-    async markRetryRequesterSenderKeyAsStale(request, requesterJid) {
+    async markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress) {
         if (!isGroupOrBroadcastJid(request.from)) {
             return;
         }
         try {
-            const requesterAddress = parseSignalAddressFromJid(requesterJid);
             const deleted = await this.senderKeyStore.markForgetSenderKey(request.from, [
                 requesterAddress
             ]);
@@ -371,12 +483,11 @@ export class WaRetryCoordinator {
             });
         }
     }
-    async fetchMissingPreKeysSession(requesterJid, requesterRegistrationId) {
+    async fetchMissingPreKeysSession(requesterJid, requesterAddress, requesterNormalizedDeviceJid, requesterRegistrationId) {
         try {
-            const requesterAddress = parseSignalAddressFromJid(requesterJid);
             const results = await this.signalMissingPreKeysSync.fetchMissingPreKeys([
                 {
-                    userJid: toUserJid(requesterJid),
+                    userJid: `${requesterAddress.user}@${requesterAddress.server}`,
                     devices: [
                         {
                             deviceId: requesterAddress.device,
@@ -393,8 +504,7 @@ export class WaRetryCoordinator {
                 });
                 return null;
             }
-            const requesterDeviceJid = normalizeDeviceJid(requesterJid);
-            const matched = first.devices.find((device) => normalizeDeviceJid(device.deviceJid) === requesterDeviceJid);
+            const matched = first.devices.find((device) => normalizeDeviceJid(device.deviceJid) === requesterNormalizedDeviceJid);
             if (!matched) {
                 this.logger.warn('missing prekeys fetch did not return requested device', {
                     requester: requesterJid,
@@ -412,33 +522,59 @@ export class WaRetryCoordinator {
             return null;
         }
     }
-    async authorizeRetryRequest(request, outbound, requesterJid) {
+    async authorizeRetryRequest(request, outbound, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
         if (outbound.state === 'ineligible') {
             return { authorized: false, reason: `state_${outbound.state}` };
         }
+        let requesterStatus = null;
+        try {
+            requesterStatus = await this.retryStore.getOutboundRequesterStatus(outbound.messageId, requesterNormalizedDeviceJid);
+        }
+        catch (error) {
+            this.logger.warn('failed to resolve outbound requester status from retry store', {
+                id: request.stanzaId,
+                originalMsgId: request.originalMsgId,
+                requester: requesterJid,
+                message: toError(error).message
+            });
+        }
+        if (requesterStatus) {
+            if (!requesterStatus.eligible) {
+                return { authorized: false, reason: 'requester_device_not_eligible' };
+            }
+            if (requesterStatus.delivered) {
+                return { authorized: false, reason: 'requester_already_delivered' };
+            }
+        }
         const isGroupOutbound = isGroupOrBroadcastJid(outbound.toJid);
         if (!isGroupOutbound && (outbound.state === 'read' || outbound.state === 'played')) {
             return { authorized: false, reason: `state_${outbound.state}` };
         }
-        const requesterAuthorized = await this.isRequesterAuthorizedDevice(requesterJid);
-        if (!requesterAuthorized) {
-            return { authorized: false, reason: 'requester_device_not_authorized' };
+        if (!requesterStatus) {
+            const requesterAuthorized = await this.isRequesterAuthorizedDevice(requesterJid, requesterAddress, requesterNormalizedDeviceJid);
+            if (!requesterAuthorized) {
+                return { authorized: false, reason: 'requester_device_not_authorized' };
+            }
         }
         return { authorized: true };
     }
-    async isRequesterAuthorizedDevice(requesterJid) {
+    async isRequesterAuthorizedDevice(requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
         try {
-            const requesterUser = toUserJid(requesterJid);
+            const requesterUser = `${requesterAddress.user}@${requesterAddress.server}`;
+            if (requesterNormalizedDeviceJid === normalizeDeviceJid(requesterUser)) {
+                return true;
+            }
             const synced = await this.signalDeviceSync.syncDeviceList([requesterUser]);
             const target = synced.find((entry) => entry.jid === requesterUser);
-            const authorized = new Set();
-            authorized.add(normalizeDeviceJid(requesterUser));
-            if (target) {
-                for (let index = 0; index < target.deviceJids.length; index += 1) {
-                    authorized.add(normalizeDeviceJid(target.deviceJids[index]));
+            if (!target) {
+                return false;
+            }
+            for (let index = 0; index < target.deviceJids.length; index += 1) {
+                if (normalizeDeviceJid(target.deviceJids[index]) === requesterNormalizedDeviceJid) {
+                    return true;
                 }
             }
-            return authorized.has(normalizeDeviceJid(requesterJid));
+            return false;
         }
         catch (error) {
             this.logger.warn('retry authorization failed while syncing requester device list', {
@@ -476,7 +612,11 @@ export class WaRetryCoordinator {
             return;
         }
         try {
-            await this.sendNode(buildInboundRetryReceiptAckNode(receiptNode));
+            await this.sendNode(buildAckNode({
+                kind: 'receipt',
+                node: receiptNode,
+                retryType: true
+            }));
         }
         catch (error) {
             this.logger.warn('failed to send retry ack', {
@@ -487,4 +627,49 @@ export class WaRetryCoordinator {
             });
         }
     }
+    async maybeCleanupRetryStore(nowMs) {
+        if (nowMs < this.nextRetryCleanupAtMs) {
+            return;
+        }
+        this.nextRetryCleanupAtMs = nowMs + RETRY_CLEANUP_INTERVAL_MS;
+        this.cleanupRetrySessionBaseKeys(nowMs);
+        try {
+            await this.retryStore.cleanupExpired(nowMs);
+        }
+        catch (error) {
+            this.logger.warn('retry store cleanup failed', {
+                message: toError(error).message
+            });
+        }
+    }
+    retrySessionBaseKeyMapKey(originalMsgId, requesterNormalizedDeviceJid) {
+        return `${originalMsgId}|${requesterNormalizedDeviceJid}`;
+    }
+    setRetrySessionBaseKey(originalMsgId, requesterNormalizedDeviceJid, baseKey, expiresAtMs) {
+        const key = this.retrySessionBaseKeyMapKey(originalMsgId, requesterNormalizedDeviceJid);
+        setBoundedMapEntry(this.retrySessionBaseKeys, key, {
+            baseKey: Uint8Array.from(baseKey),
+            expiresAtMs
+        }, RETRY_SESSION_BASE_KEY_CACHE_MAX_ENTRIES);
+    }
+    getRetrySessionBaseKey(originalMsgId, requesterNormalizedDeviceJid) {
+        const key = this.retrySessionBaseKeyMapKey(originalMsgId, requesterNormalizedDeviceJid);
+        const entry = this.retrySessionBaseKeys.get(key);
+        if (!entry) {
+            return null;
+        }
+        if (entry.expiresAtMs <= Date.now()) {
+            this.retrySessionBaseKeys.delete(key);
+            return null;
+        }
+        return entry;
+    }
+    cleanupRetrySessionBaseKeys(nowMs) {
+        for (const [key, entry] of this.retrySessionBaseKeys) {
+            if (entry.expiresAtMs > nowMs) {
+                continue;
+            }
+            this.retrySessionBaseKeys.delete(key);
+        }
+    }
 }

package/dist/esm/client/coordinators/WaStreamControlCoordinator.js

@@ -1,4 +1,4 @@
-import { WA_DISCONNECT_REASONS, WA_STREAM_SIGNALING } from '../../protocol/constants.js';
+import { WA_CONNECTION_REASONS, WA_DISCONNECT_REASONS, WA_STREAM_SIGNALING } from '../../protocol/constants.js';
 import { toError } from '../../util/primitives.js';
 export function createStreamControlHandler(options) {
     const { logger, getComms, clearPendingQueries, clearMediaConnCache, disconnect, clearStoredCredentials, connect } = options;
@@ -16,7 +16,7 @@ export function createStreamControlHandler(options) {
     const restartBackendAfterStreamControl = async (reason) => {
         logger.info('restarting backend after stream control', { reason });
         try {
-            await connect();
+            await connect(WA_CONNECTION_REASONS.RECONNECTED);
         }
         catch (error) {
             logger.warn('failed to restart backend after stream control', {
@@ -43,29 +43,36 @@ export function createStreamControlHandler(options) {
             });
         }
     };
+    const stopCommsImmediately = () => {
+        void getComms()?.stopComms();
+    };
     const forceLoginDueToStreamError = async (code) => {
-        await runStreamControlLifecycle(`stream_error_code_${code}`, async () => {
+        const reason = WA_DISCONNECT_REASONS.STREAM_ERROR_FORCE_LOGIN;
+        stopCommsImmediately();
+        await runStreamControlLifecycle(reason, async () => {
             logger.warn('received forced login stream error; starting login lifecycle', {
                 code
             });
-            await disconnect();
+            await disconnect(reason, true, code);
             await clearStoredCredentials();
-            await restartBackendAfterStreamControl(`stream_error_code_${code}`);
+            await restartBackendAfterStreamControl(reason);
         });
     };
-    const disconnectDueToStreamError = async (reason) => {
+    const disconnectDueToStreamError = async (reason, code) => {
+        stopCommsImmediately();
         await runStreamControlLifecycle(reason, async () => {
             logger.warn('disconnecting due to stream control node', { reason });
-            await disconnect();
+            await disconnect(reason, false, code);
         });
     };
-    const logoutDueToStreamError = async (reason, shouldRestartBackend) => {
+    const logoutDueToStreamError = async (reason, code, shouldRestartBackend) => {
+        stopCommsImmediately();
         await runStreamControlLifecycle(reason, async () => {
             logger.warn('logging out due to stream control node', {
                 reason,
                 shouldRestartBackend
             });
-            await disconnect();
+            await disconnect(reason, true, code);
             await clearStoredCredentials();
             if (shouldRestartBackend) {
                 await restartBackendAfterStreamControl(reason);
@@ -86,7 +93,7 @@ export function createStreamControlHandler(options) {
                             return;
                         }
                         if (result.code === WA_STREAM_SIGNALING.FORCE_LOGOUT_CODE) {
-                            await logoutDueToStreamError(`stream_error_code_${WA_STREAM_SIGNALING.FORCE_LOGOUT_CODE}`, true);
+                            await logoutDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_FORCE_LOGOUT, result.code, true);
                             return;
                         }
                     }
@@ -94,11 +101,11 @@ export function createStreamControlHandler(options) {
                     return;
                 case 'stream_error_replaced':
                     logger.warn('received stream:error replaced, stopping client');
-                    await disconnectDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_REPLACED);
+                    await disconnectDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_REPLACED, null);
                     return;
                 case 'stream_error_device_removed':
                     logger.warn('received stream:error device removed, logging out');
-                    await logoutDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_DEVICE_REMOVED, false);
+                    await logoutDueToStreamError(WA_DISCONNECT_REASONS.STREAM_ERROR_DEVICE_REMOVED, null, false);
                     return;
                 case 'stream_error_ack':
                     logger.warn('received stream:error ack', { id: result.id });