zapo-js 0.1.2 → 0.2.0

package/dist/auth/index.js

@@ -14,12 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaAuthSqliteStore = exports.createCompanionHello = exports.completeCompanionFinish = exports.WaAuthClient = void 0;
+exports.WaAuthClient = void 0;
 __exportStar(require("./types"), exports);
 var WaAuthClient_1 = require("./WaAuthClient");
 Object.defineProperty(exports, "WaAuthClient", { enumerable: true, get: function () { return WaAuthClient_1.WaAuthClient; } });
-var WaPairingCodeCrypto_1 = require("./pairing/WaPairingCodeCrypto");
-Object.defineProperty(exports, "completeCompanionFinish", { enumerable: true, get: function () { return WaPairingCodeCrypto_1.completeCompanionFinish; } });
-Object.defineProperty(exports, "createCompanionHello", { enumerable: true, get: function () { return WaPairingCodeCrypto_1.createCompanionHello; } });
-var auth_store_1 = require("../store/providers/sqlite/auth.store");
-Object.defineProperty(exports, "WaAuthSqliteStore", { enumerable: true, get: function () { return auth_store_1.WaAuthSqliteStore; } });

package/dist/auth/pairing/WaPairingCodeCrypto.js

@@ -49,8 +49,8 @@ async function completeCompanionFinish(args) {
     if (primaryEphemeralPub.length === 0) {
         throw new Error('empty primary ephemeral public key');
     }
-    const sharedEphemeral = await X25519_1.X25519.scalarMult(args.companionEphemeralPrivKey, primaryEphemeralPub);
-    const [bundleSalt, bundleSecret, bundleIv] = await Promise.all([
+    const [sharedEphemeral, bundleSalt, bundleSecret, bundleIv] = await Promise.all([
+        X25519_1.X25519.scalarMult(args.companionEphemeralPrivKey, primaryEphemeralPub),
         (0, _crypto_1.randomBytesAsync)(32),
         (0, _crypto_1.randomBytesAsync)(32),
         (0, _crypto_1.randomBytesAsync)(12)
@@ -62,9 +62,11 @@ async function completeCompanionFinish(args) {
         args.primaryIdentityPub,
         bundleSecret
     ]);
-    const encryptedBundle = await (0, _crypto_1.aesGcmEncrypt)(bundleEncryptionKey, bundleIv, plaintextBundle);
+    const [encryptedBundle, sharedIdentity] = await Promise.all([
+        (0, _crypto_1.aesGcmEncrypt)(bundleEncryptionKey, bundleIv, plaintextBundle),
+        X25519_1.X25519.scalarMult(args.registrationIdentityKeyPair.privKey, args.primaryIdentityPub)
+    ]);
     const wrappedKeyBundle = (0, bytes_1.concatBytes)([bundleSalt, bundleIv, encryptedBundle]);
-    const sharedIdentity = await X25519_1.X25519.scalarMult(args.registrationIdentityKeyPair.privKey, args.primaryIdentityPub);
     const advMaterial = (0, bytes_1.concatBytes)([sharedEphemeral, sharedIdentity, bundleSecret]);
     const advSecret = await (0, _crypto_1.hkdf)(advMaterial, null, constants_2.WA_PAIRING_KDF_INFO.ADV_SECRET, 32);
     return {

package/dist/auth/pairing/WaPairingFlow.js

@@ -7,6 +7,7 @@ const _proto_1 = require("../../proto.js");
 const constants_1 = require("../../protocol/constants");
 const jid_1 = require("../../protocol/jid");
 const WaAdvSignature_1 = require("../../signal/crypto/WaAdvSignature");
+const global_1 = require("../../transport/node/builders/global");
 const pairing_1 = require("../../transport/node/builders/pairing");
 const helpers_1 = require("../../transport/node/helpers");
 const bytes_1 = require("../../util/bytes");
@@ -121,7 +122,10 @@ class WaPairingFlow {
             id: node.attrs.id,
             stage: linkCodeNode.attrs.stage
         });
-        await this.opts.socket.sendNode((0, pairing_1.buildNotificationAckNode)(node));
+        await this.opts.socket.sendNode((0, global_1.buildAckNode)({
+            kind: 'notification',
+            node
+        }));
         const stage = linkCodeNode.attrs.stage;
         if (stage === constants_1.WA_SIGNALING.LINK_CODE_STAGE_REFRESH_CODE) {
             const refNode = (0, helpers_1.findNodeChild)(linkCodeNode, constants_1.WA_NODE_TAGS.LINK_CODE_PAIRING_REF);
@@ -149,18 +153,24 @@ class WaPairingFlow {
         if (!hasExpectedChild) {
             return false;
         }
-        await this.opts.socket.sendNode((0, pairing_1.buildNotificationAckNode)(node, constants_1.WA_SIGNALING.COMPANION_REG_REFRESH_NOTIFICATION));
+        // Rotate first so we don't ack success before local credential state is durably updated.
         await this.rotateAdvSecret(this.requireCredentials());
+        await this.opts.socket.sendNode((0, global_1.buildAckNode)({
+            kind: 'notification',
+            node,
+            typeOverride: constants_1.WA_SIGNALING.COMPANION_REG_REFRESH_NOTIFICATION
+        }));
         this.opts.logger.info('handled companion_reg_refresh notification');
         this.opts.qrFlow.refreshCurrentQr();
         return true;
     }
     async handlePairDevice(iqNode, pairDeviceNode) {
         const refs = (0, helpers_1.getNodeChildrenNonEmptyUtf8ByTag)(pairDeviceNode, constants_1.WA_NODE_TAGS.REF, 'pair-device.ref');
+        // Commit adv-secret rotation before sending IQ success to avoid protocol/state divergence.
         await this.rotateAdvSecret(this.requireCredentials());
+        await this.opts.socket.sendNode((0, global_1.buildIqResultNode)(iqNode));
         this.opts.qrFlow.setRefs(refs);
         this.opts.logger.info('pair-device refs updated', { refsCount: refs.length });
-        await this.opts.socket.sendNode((0, pairing_1.buildIqResultNode)(iqNode));
     }
     async handlePairSuccess(iqNode, pairSuccessNode) {
         this.opts.logger.info('processing pair-success node');

package/dist/client/WaClient.js

@@ -6,6 +6,7 @@ const utils_1 = require("../appstate/utils");
 const chat_1 = require("./events/chat");
 const history_sync_1 = require("./history-sync");
 const mailbox_1 = require("./mailbox");
+const WriteBehindPersistence_1 = require("./persistence/WriteBehindPersistence");
 const WaClientFactory_1 = require("./WaClientFactory");
 const ConsoleLogger_1 = require("../infra/log/ConsoleLogger");
 const _proto_1 = require("../proto.js");
@@ -27,6 +28,9 @@ class WaClient extends node_events_1.EventEmitter {
     constructor(options, logger = new ConsoleLogger_1.ConsoleLogger('info')) {
         super();
         this.connectPromise = null;
+        this.acceptingIncomingEvents = true;
+        this.activeIncomingHandlers = 0;
+        this.incomingHandlersDrainedWaiters = [];
         const base = (0, WaClientFactory_1.resolveWaClientBase)(options, logger);
         this.options = base.options;
         this.logger = base.logger;
@@ -34,11 +38,17 @@ class WaClient extends node_events_1.EventEmitter {
         this.contactStore = base.sessionStore.contacts;
         this.messageStore = base.sessionStore.messages;
         this.participantsStore = base.sessionStore.participants;
+        this.privacyTokenStore = base.sessionStore.privacyToken;
         this.deviceListStore = base.sessionStore.deviceList;
         this.retryStore = base.sessionStore.retry;
         this.signalStore = base.sessionStore.signal;
         this.senderKeyStore = base.sessionStore.senderKey;
         this.threadStore = base.sessionStore.threads;
+        this.writeBehind = new WriteBehindPersistence_1.WriteBehindPersistence({
+            messageStore: this.messageStore,
+            threadStore: this.threadStore,
+            contactStore: this.contactStore
+        }, this.logger, this.options.writeBehind);
         const dependencies = (0, WaClientFactory_1.buildWaClientDependencies)({
             base,
             runtime: {
@@ -51,7 +61,10 @@ class WaClient extends node_events_1.EventEmitter {
                 handleIncomingMessageEvent: this.handleIncomingMessageEvent.bind(this),
                 handleError: this.handleError.bind(this),
                 handleIncomingFrame: this.handleIncomingFrame.bind(this),
-                clearStoredState: this.clearStoredState.bind(this)
+                clearStoredState: this.clearStoredState.bind(this),
+                resumeIncomingEvents: () => {
+                    this.acceptingIncomingEvents = true;
+                }
             }
         });
         Object.assign(this, dependencies);
@@ -122,63 +135,65 @@ class WaClient extends node_events_1.EventEmitter {
             this.handleError(error);
         });
     }
-    getMailboxPersistenceDeps() {
-        return {
-            logger: this.logger,
-            contactStore: this.contactStore,
-            messageStore: this.messageStore
-        };
-    }
     async handleIncomingMessageEvent(event) {
-        this.emit('message', event);
-        void (0, mailbox_1.persistIncomingMailboxEntities)({
-            ...this.getMailboxPersistenceDeps(),
-            event
-        });
-        const protocolMessage = event.message?.protocolMessage;
-        if (!protocolMessage) {
+        if (!this.tryEnterIncomingHandler()) {
             return;
         }
-        const protocolEvent = {
-            ...event,
-            protocolMessage
-        };
-        this.emit('message_protocol', protocolEvent);
-        const protocolType = protocolMessage.type;
-        if (protocolType === null || protocolType === undefined) {
-            this.logger.debug('incoming protocol message without type', {
-                id: event.stanzaId,
-                from: event.chatJid
+        try {
+            this.emit('message', event);
+            void (0, mailbox_1.persistIncomingMailboxEntities)({
+                logger: this.logger,
+                writeBehind: this.writeBehind,
+                event
             });
-            return;
-        }
-        if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST) {
-            await this.handleIncomingAppStateSyncKeyRequest(event, protocolMessage);
-            return;
-        }
-        if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE) {
-            await this.handleIncomingAppStateSyncKeyShare(event, protocolMessage);
-            return;
-        }
-        if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION) {
-            if (this.options.history?.enabled && protocolMessage.historySyncNotification) {
-                await this.handleHistorySyncNotification(protocolMessage.historySyncNotification);
+            const protocolMessage = event.message?.protocolMessage;
+            if (!protocolMessage) {
+                return;
             }
-            return;
-        }
-        if (SYNC_RELATED_PROTOCOL_TYPES.has(protocolType)) {
-            this.logger.info('incoming sync-related protocol message', {
+            const protocolEvent = {
+                ...event,
+                protocolMessage
+            };
+            this.emit('message_protocol', protocolEvent);
+            const protocolType = protocolMessage.type;
+            if (protocolType === null || protocolType === undefined) {
+                this.logger.debug('incoming protocol message without type', {
+                    id: event.stanzaId,
+                    from: event.chatJid
+                });
+                return;
+            }
+            if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST) {
+                await this.handleIncomingAppStateSyncKeyRequest(event, protocolMessage);
+                return;
+            }
+            if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE) {
+                await this.handleIncomingAppStateSyncKeyShare(event, protocolMessage);
+                return;
+            }
+            if (protocolType === _proto_1.proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION) {
+                if (this.options.history?.enabled && protocolMessage.historySyncNotification) {
+                    await this.handleHistorySyncNotification(protocolMessage.historySyncNotification);
+                }
+                return;
+            }
+            if (SYNC_RELATED_PROTOCOL_TYPES.has(protocolType)) {
+                this.logger.info('incoming sync-related protocol message', {
+                    id: event.stanzaId,
+                    from: event.chatJid,
+                    protocolType
+                });
+                return;
+            }
+            this.logger.debug('incoming protocol message received', {
                 id: event.stanzaId,
                 from: event.chatJid,
                 protocolType
             });
-            return;
         }
-        this.logger.debug('incoming protocol message received', {
-            id: event.stanzaId,
-            from: event.chatJid,
-            protocolType
-        });
+        finally {
+            this.leaveIncomingHandler();
+        }
     }
     async handleIncomingAppStateSyncKeyShare(event, protocolMessage) {
         const share = protocolMessage.appStateSyncKeyShare;
@@ -267,9 +282,18 @@ class WaClient extends node_events_1.EventEmitter {
             });
             return;
         }
-        const requestedKeys = await Promise.all(requestedKeyIds.map((keyId) => this.appStateStore.getSyncKey(keyId)));
-        const availableKeys = requestedKeys.filter((key) => key !== null);
-        const missingKeyIds = requestedKeyIds.filter((_, index) => requestedKeys[index] === null);
+        const requestedKeys = await this.appStateStore.getSyncKeysBatch(requestedKeyIds);
+        const availableKeys = [];
+        const missingKeyIds = [];
+        for (let i = 0; i < requestedKeys.length; i += 1) {
+            const key = requestedKeys[i];
+            if (key !== null) {
+                availableKeys.push(key);
+            }
+            else {
+                missingKeyIds.push(requestedKeyIds[i]);
+            }
+        }
         try {
             await this.messageDispatch.sendAppStateSyncKeyShare(requesterDeviceJid, availableKeys, missingKeyIds);
             this.logger.info('responded to app-state key request', {
@@ -316,18 +340,18 @@ class WaClient extends node_events_1.EventEmitter {
             return false;
         }
         const candidateUser = (0, jid_1.toUserJid)(candidateJid);
-        const meUsers = [credentials.meJid, credentials.meLid]
-            .filter((value) => !!value)
-            .map((jid) => (0, jid_1.toUserJid)(jid));
-        return meUsers.includes(candidateUser);
+        return ((!!credentials.meJid && (0, jid_1.toUserJid)(credentials.meJid) === candidateUser) ||
+            (!!credentials.meLid && (0, jid_1.toUserJid)(credentials.meLid) === candidateUser));
     }
     async handleHistorySyncNotification(notification) {
         try {
             await (0, history_sync_1.processHistorySyncNotification)({
-                ...this.getMailboxPersistenceDeps(),
+                logger: this.logger,
                 mediaTransfer: this.mediaTransfer,
-                threadStore: this.threadStore,
-                emitEvent: this.emit.bind(this)
+                writeBehind: this.writeBehind,
+                emitEvent: this.emit.bind(this),
+                onPrivacyTokens: (conversations) => this.trustedContactToken.hydrateFromHistorySync(conversations),
+                onNctSalt: (salt) => this.trustedContactToken.hydrateNctSaltFromHistorySync(salt)
             }, notification);
         }
         catch (error) {
@@ -354,10 +378,17 @@ class WaClient extends node_events_1.EventEmitter {
             this.logger.trace('wa client connect already in-flight');
             return this.connectPromise;
         }
+        this.acceptingIncomingEvents = true;
         this.connectPromise = this.connectionManager
             .connect((frame) => this.handleIncomingFrame(frame))
             .then(() => {
-            this.emit('connection_open', {});
+            this.emit('connection', {
+                status: 'open',
+                reason: 'connected',
+                code: null,
+                isLogout: false,
+                isNewLogin: this.connectionManager.wasNewLogin()
+            });
         })
             .finally(() => {
             this.connectPromise = null;
@@ -365,9 +396,22 @@ class WaClient extends node_events_1.EventEmitter {
         return this.connectPromise;
     }
     async disconnect() {
+        await this.pauseIncomingEventsAndWaitDrain();
+        const writeBehindFlush = await this.writeBehind.flush(this.options.writeBehind?.flushTimeoutMs);
+        if (writeBehindFlush.remaining > 0) {
+            this.logger.warn('disconnect continuing with pending write-behind entries', {
+                remaining: writeBehindFlush.remaining
+            });
+        }
         this.keyShareCoordinator.notifyDisconnected();
         await this.connectionManager.disconnect();
-        this.emit('connection_close', {});
+        this.emit('connection', {
+            status: 'close',
+            reason: 'client_disconnected',
+            code: null,
+            isLogout: false,
+            isNewLogin: false
+        });
     }
     async requestPairingCode(phoneNumber, shouldShowPushNotification = false) {
         if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
@@ -387,7 +431,10 @@ class WaClient extends node_events_1.EventEmitter {
         if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
             throw new Error('client is not connected');
         }
-        const normalizedPhoneJids = phoneNumbers.map(jid_1.parsePhoneJid);
+        const normalizedPhoneJids = new Array(phoneNumbers.length);
+        for (let index = 0; index < phoneNumbers.length; index += 1) {
+            normalizedPhoneJids[index] = (0, jid_1.parsePhoneJid)(phoneNumbers[index]);
+        }
         this.logger.trace('wa client query lids by phone numbers', {
             phones: normalizedPhoneJids.length
         });
@@ -396,41 +443,38 @@ class WaClient extends node_events_1.EventEmitter {
     sendMessage(to, content, options = {}) {
         return this.messageDispatch.sendMessage(to, content, options);
     }
-    syncSignalSession(jid, reasonIdentity = false) {
-        return this.messageDispatch.syncSignalSession(jid, reasonIdentity);
-    }
-    sendReceipt(input) {
-        return this.messageDispatch.sendReceipt(input);
-    }
-    setChatMute(chatJid, muted, muteEndTimestampMs) {
-        return this.appStateMutations.setChatMute(chatJid, muted, muteEndTimestampMs);
-    }
-    setChatRead(chatJid, read) {
-        return this.appStateMutations.setChatRead(chatJid, read);
-    }
-    setChatPin(chatJid, pinned) {
-        return this.appStateMutations.setChatPin(chatJid, pinned);
+    async syncSignalSession(jid, reasonIdentity = false) {
+        await this.messageDispatch.syncSignalSession(jid, reasonIdentity);
+        if (reasonIdentity) {
+            this.trustedContactToken.reissueOnIdentityChange(jid).catch((err) => this.logger.warn('tc token reissue on identity change failed', {
+                jid,
+                message: (0, primitives_1.toError)(err).message
+            }));
+        }
     }
-    setChatArchive(chatJid, archived) {
-        return this.appStateMutations.setChatArchive(chatJid, archived);
+    get chat() {
+        return this.chatCoordinator;
     }
-    clearChat(chatJid, options = {}) {
-        return this.appStateMutations.clearChat(chatJid, options);
+    get group() {
+        return this.groupCoordinator;
     }
-    deleteChat(chatJid, options = {}) {
-        return this.appStateMutations.deleteChat(chatJid, options);
+    get privacy() {
+        return this.privacyCoordinator;
     }
-    setChatLock(chatJid, locked) {
-        return this.appStateMutations.setChatLock(chatJid, locked);
+    get profile() {
+        return this.profileCoordinator;
     }
-    setMessageStar(message, starred) {
-        return this.appStateMutations.setMessageStar(message, starred);
+    get business() {
+        return this.businessCoordinator;
     }
-    deleteMessageForMe(message, options = {}) {
-        return this.appStateMutations.deleteMessageForMe(message, options);
+    sendReceipt(input) {
+        return this.messageDispatch.sendReceipt(input);
     }
     flushAppStateMutations() {
-        return this.appStateMutations.flushMutations();
+        return this.chatCoordinator.flushMutations();
+    }
+    flushWriteBehind(timeoutMs) {
+        return this.writeBehind.flush(timeoutMs);
     }
     async exportAppState() {
         return this.appStateSync.exportState();
@@ -507,9 +551,13 @@ class WaClient extends node_events_1.EventEmitter {
             });
     }
     getBlockedAppStateCollections(syncResult) {
-        return syncResult.collections
-            .filter((entry) => entry.state === constants_1.WA_APP_STATE_COLLECTION_STATES.BLOCKED)
-            .map((entry) => entry.collection);
+        const blocked = [];
+        for (const entry of syncResult.collections) {
+            if (entry.state === constants_1.WA_APP_STATE_COLLECTION_STATES.BLOCKED) {
+                blocked.push(entry.collection);
+            }
+        }
+        return blocked;
     }
     emitChatEventsFromAppStateSyncResult(syncResult) {
         const shouldEmitSnapshotMutations = this.options.chatEvents?.emitSnapshotMutations === true;
@@ -533,6 +581,7 @@ class WaClient extends node_events_1.EventEmitter {
                     continue;
                 }
                 try {
+                    this.handleNctSaltMutation(mutation);
                     const event = (0, chat_1.parseChatEventFromAppStateMutation)(mutation);
                     if (!event) {
                         continue;
@@ -550,23 +599,98 @@ class WaClient extends node_events_1.EventEmitter {
             }
         }
     }
+    handleNctSaltMutation(mutation) {
+        const nctAction = mutation.value?.nctSaltSyncAction;
+        if (!nctAction) {
+            return;
+        }
+        if (mutation.operation === 'set' && nctAction.salt) {
+            this.trustedContactToken.handleNctSaltSync(nctAction.salt).catch((err) => this.logger.warn('nct salt sync set failed', {
+                message: (0, primitives_1.toError)(err).message
+            }));
+        }
+        else if (mutation.operation === 'remove') {
+            this.trustedContactToken.handleNctSaltSync(null).catch((err) => this.logger.warn('nct salt sync remove failed', {
+                message: (0, primitives_1.toError)(err).message
+            }));
+        }
+    }
     async clearStoredState() {
+        await this.pauseIncomingEventsAndWaitDrain();
+        const writeBehindDestroy = await this.writeBehind.destroy(this.options.writeBehind?.flushTimeoutMs);
+        if (writeBehindDestroy.remaining > 0) {
+            throw new Error(`clear stored state aborted: write-behind did not fully drain (remaining=${writeBehindDestroy.remaining})`);
+        }
         const danglingReceipts = this.receiptQueue.take();
         if (danglingReceipts.length > 0) {
             this.logger.debug('cleared dangling receipts while clearing stored state', {
                 count: danglingReceipts.length
             });
         }
-        await this.authClient.clearStoredCredentials();
-        await this.appStateStore.clear();
-        await this.contactStore.clear();
-        await this.messageStore.clear();
-        await this.participantsStore.clear();
-        await this.deviceListStore.clear();
-        await this.retryStore.clear();
-        await this.signalStore.clear();
-        await this.senderKeyStore.clear();
-        await this.threadStore.clear();
+        const s = this.options.logoutStoreClear;
+        const shouldClear = (key) => s === undefined || s[key] !== false;
+        if (shouldClear('auth'))
+            await this.authClient.clearStoredCredentials();
+        if (shouldClear('appState'))
+            await this.appStateStore.clear();
+        if (shouldClear('contacts'))
+            await this.contactStore.clear();
+        if (shouldClear('messages'))
+            await this.messageStore.clear();
+        if (shouldClear('participants'))
+            await this.participantsStore.clear();
+        if (shouldClear('deviceList'))
+            await this.deviceListStore.clear();
+        if (shouldClear('retry'))
+            await this.retryStore.clear();
+        if (shouldClear('signal'))
+            await this.signalStore.clear();
+        if (shouldClear('senderKey'))
+            await this.senderKeyStore.clear();
+        if (shouldClear('threads'))
+            await this.threadStore.clear();
+        if (shouldClear('privacyToken'))
+            await this.privacyTokenStore.clear();
+    }
+    tryEnterIncomingHandler() {
+        if (!this.acceptingIncomingEvents) {
+            return false;
+        }
+        this.activeIncomingHandlers += 1;
+        if (this.acceptingIncomingEvents) {
+            return true;
+        }
+        this.leaveIncomingHandler();
+        return false;
+    }
+    leaveIncomingHandler() {
+        if (this.activeIncomingHandlers <= 0) {
+            return;
+        }
+        this.activeIncomingHandlers -= 1;
+        if (this.activeIncomingHandlers === 0) {
+            this.notifyIncomingHandlersDrained();
+        }
+    }
+    async pauseIncomingEventsAndWaitDrain() {
+        this.acceptingIncomingEvents = false;
+        if (this.activeIncomingHandlers === 0) {
+            return;
+        }
+        await new Promise((resolve) => {
+            this.incomingHandlersDrainedWaiters[this.incomingHandlersDrainedWaiters.length] =
+                resolve;
+        });
+    }
+    notifyIncomingHandlersDrained() {
+        if (this.incomingHandlersDrainedWaiters.length === 0) {
+            return;
+        }
+        const waitersLength = this.incomingHandlersDrainedWaiters.length;
+        for (let index = 0; index < waitersLength; index += 1) {
+            this.incomingHandlersDrainedWaiters[index]();
+        }
+        this.incomingHandlersDrainedWaiters.length = 0;
     }
     handleError(error) {
         this.logger.error('wa client error', { message: error.message });