zapo-js 0.1.2 → 0.2.0

package/dist/esm/auth/pairing/WaPairingCodeCrypto.js

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

package/dist/esm/auth/pairing/WaPairingFlow.js

@@ -4,7 +4,8 @@ import { proto } from '../../proto.js';
 import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_SIGNALING } from '../../protocol/constants.js';
 import { parsePhoneJid } from '../../protocol/jid.js';
 import { ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, computeAdvIdentityHmac, generateDeviceSignature, verifyDeviceIdentityAccountSignature } from '../../signal/crypto/WaAdvSignature.js';
-import { buildCompanionFinishRequestNode, buildCompanionHelloRequestNode, buildGetCountryCodeRequestNode, buildIqResultNode, buildNotificationAckNode } from '../../transport/node/builders/pairing.js';
+import { buildAckNode, buildIqResultNode } from '../../transport/node/builders/global.js';
+import { buildCompanionFinishRequestNode, buildCompanionHelloRequestNode, buildGetCountryCodeRequestNode } from '../../transport/node/builders/pairing.js';
 import { decodeNodeContentUtf8OrBytes, findNodeChildrenByTags, findNodeChild, getFirstNodeChild, getNodeChildrenNonEmptyUtf8ByTag, hasNodeChild } from '../../transport/node/helpers.js';
 import { decodeProtoBytes } from '../../util/bytes.js';
 import { concatBytes, uint8Equal } from '../../util/bytes.js';
@@ -118,7 +119,10 @@ export class WaPairingFlow {
             id: node.attrs.id,
             stage: linkCodeNode.attrs.stage
         });
-        await this.opts.socket.sendNode(buildNotificationAckNode(node));
+        await this.opts.socket.sendNode(buildAckNode({
+            kind: 'notification',
+            node
+        }));
         const stage = linkCodeNode.attrs.stage;
         if (stage === WA_SIGNALING.LINK_CODE_STAGE_REFRESH_CODE) {
             const refNode = findNodeChild(linkCodeNode, WA_NODE_TAGS.LINK_CODE_PAIRING_REF);
@@ -146,18 +150,24 @@ export class WaPairingFlow {
         if (!hasExpectedChild) {
             return false;
         }
-        await this.opts.socket.sendNode(buildNotificationAckNode(node, 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(buildAckNode({
+            kind: 'notification',
+            node,
+            typeOverride: 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 = getNodeChildrenNonEmptyUtf8ByTag(pairDeviceNode, 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(buildIqResultNode(iqNode));
         this.opts.qrFlow.setRefs(refs);
         this.opts.logger.info('pair-device refs updated', { refsCount: refs.length });
-        await this.opts.socket.sendNode(buildIqResultNode(iqNode));
     }
     async handlePairSuccess(iqNode, pairSuccessNode) {
         this.opts.logger.info('processing pair-success node');

package/dist/esm/client/WaClient.js

@@ -3,6 +3,7 @@ import { downloadExternalBlobReference } from '../appstate/utils.js';
 import { parseChatEventFromAppStateMutation } from './events/chat.js';
 import { processHistorySyncNotification } from './history-sync.js';
 import { persistIncomingMailboxEntities } from './mailbox.js';
+import { WriteBehindPersistence } from './persistence/WriteBehindPersistence.js';
 import { buildWaClientDependencies, resolveWaClientBase } from './WaClientFactory.js';
 import { ConsoleLogger } from '../infra/log/ConsoleLogger.js';
 import { proto } from '../proto.js';
@@ -24,6 +25,9 @@ export class WaClient extends EventEmitter {
     constructor(options, logger = new ConsoleLogger('info')) {
         super();
         this.connectPromise = null;
+        this.acceptingIncomingEvents = true;
+        this.activeIncomingHandlers = 0;
+        this.incomingHandlersDrainedWaiters = [];
         const base = resolveWaClientBase(options, logger);
         this.options = base.options;
         this.logger = base.logger;
@@ -31,11 +35,17 @@ export class WaClient extends 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({
+            messageStore: this.messageStore,
+            threadStore: this.threadStore,
+            contactStore: this.contactStore
+        }, this.logger, this.options.writeBehind);
         const dependencies = buildWaClientDependencies({
             base,
             runtime: {
@@ -48,7 +58,10 @@ export class WaClient extends 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);
@@ -119,63 +132,65 @@ export class WaClient extends EventEmitter {
             this.handleError(error);
         });
     }
-    getMailboxPersistenceDeps() {
-        return {
-            logger: this.logger,
-            contactStore: this.contactStore,
-            messageStore: this.messageStore
-        };
-    }
     async handleIncomingMessageEvent(event) {
-        this.emit('message', event);
-        void 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 persistIncomingMailboxEntities({
+                logger: this.logger,
+                writeBehind: this.writeBehind,
+                event
             });
-            return;
-        }
-        if (protocolType === proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST) {
-            await this.handleIncomingAppStateSyncKeyRequest(event, protocolMessage);
-            return;
-        }
-        if (protocolType === proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE) {
-            await this.handleIncomingAppStateSyncKeyShare(event, protocolMessage);
-            return;
-        }
-        if (protocolType === 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.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST) {
+                await this.handleIncomingAppStateSyncKeyRequest(event, protocolMessage);
+                return;
+            }
+            if (protocolType === proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE) {
+                await this.handleIncomingAppStateSyncKeyShare(event, protocolMessage);
+                return;
+            }
+            if (protocolType === 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;
@@ -264,9 +279,18 @@ export class WaClient extends 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', {
@@ -313,18 +337,18 @@ export class WaClient extends EventEmitter {
             return false;
         }
         const candidateUser = toUserJid(candidateJid);
-        const meUsers = [credentials.meJid, credentials.meLid]
-            .filter((value) => !!value)
-            .map((jid) => toUserJid(jid));
-        return meUsers.includes(candidateUser);
+        return ((!!credentials.meJid && toUserJid(credentials.meJid) === candidateUser) ||
+            (!!credentials.meLid && toUserJid(credentials.meLid) === candidateUser));
     }
     async handleHistorySyncNotification(notification) {
         try {
             await 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) {
@@ -351,10 +375,17 @@ export class WaClient extends 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;
@@ -362,9 +393,22 @@ export class WaClient extends 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()) {
@@ -384,7 +428,10 @@ export class WaClient extends EventEmitter {
         if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
             throw new Error('client is not connected');
         }
-        const normalizedPhoneJids = phoneNumbers.map(parsePhoneJid);
+        const normalizedPhoneJids = new Array(phoneNumbers.length);
+        for (let index = 0; index < phoneNumbers.length; index += 1) {
+            normalizedPhoneJids[index] = parsePhoneJid(phoneNumbers[index]);
+        }
         this.logger.trace('wa client query lids by phone numbers', {
             phones: normalizedPhoneJids.length
         });
@@ -393,41 +440,38 @@ export class WaClient extends 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: 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();
@@ -504,9 +548,13 @@ export class WaClient extends EventEmitter {
             });
     }
     getBlockedAppStateCollections(syncResult) {
-        return syncResult.collections
-            .filter((entry) => entry.state === WA_APP_STATE_COLLECTION_STATES.BLOCKED)
-            .map((entry) => entry.collection);
+        const blocked = [];
+        for (const entry of syncResult.collections) {
+            if (entry.state === WA_APP_STATE_COLLECTION_STATES.BLOCKED) {
+                blocked.push(entry.collection);
+            }
+        }
+        return blocked;
     }
     emitChatEventsFromAppStateSyncResult(syncResult) {
         const shouldEmitSnapshotMutations = this.options.chatEvents?.emitSnapshotMutations === true;
@@ -530,6 +578,7 @@ export class WaClient extends EventEmitter {
                     continue;
                 }
                 try {
+                    this.handleNctSaltMutation(mutation);
                     const event = parseChatEventFromAppStateMutation(mutation);
                     if (!event) {
                         continue;
@@ -547,23 +596,98 @@ export class WaClient extends 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: toError(err).message
+            }));
+        }
+        else if (mutation.operation === 'remove') {
+            this.trustedContactToken.handleNctSaltSync(null).catch((err) => this.logger.warn('nct salt sync remove failed', {
+                message: 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 });