zapo-js 0.2.0 → 0.3.0

package/dist/esm/client/WaClient.js

@@ -6,12 +6,16 @@ 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 { buildAddonAdditionalData, decodeAddonPlaintext, decryptAddonPayload, identifyEncryptedAddon, resolveParentMessageSecret, resolvePollOptionNames, shouldUseAddonAdditionalData } from '../message/addon-crypto.js';
 import { proto } from '../proto.js';
 import { WA_APP_STATE_COLLECTION_STATES, WA_DEFAULTS } from '../protocol/constants.js';
 import { normalizeDeviceJid, parsePhoneJid, toUserJid } from '../protocol/jid.js';
-import { queryWithContext as queryNodeWithContext } from '../transport/node/query.js';
-import { decodeProtoBytes } from '../util/bytes.js';
-import { bytesToHex } from '../util/bytes.js';
+import { WA_LOGOUT_REASONS } from '../protocol/stream.js';
+import { NOOP_MESSAGE_SECRET_STORE } from '../store/noop.store.js';
+import { buildRemoveCompanionDeviceIq } from '../transport/node/builders/device.js';
+import { buildPresenceNode } from '../transport/node/builders/presence.js';
+import { assertIqResult, queryWithContext as queryNodeWithContext } from '../transport/node/query.js';
+import { bytesToHex, decodeProtoBytes } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 const SYNC_RELATED_PROTOCOL_TYPES = new Set([
     proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST,
@@ -19,8 +23,6 @@ const SYNC_RELATED_PROTOCOL_TYPES = new Set([
     proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_MESSAGE,
     proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE
 ]);
-const WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS = 15000;
-const WA_APP_STATE_KEY_SHARE_MAX_RETRIES = 2;
 export class WaClient extends EventEmitter {
     constructor(options, logger = new ConsoleLogger('info')) {
         super();
@@ -34,11 +36,15 @@ export class WaClient extends EventEmitter {
         this.appStateStore = base.sessionStore.appState;
         this.contactStore = base.sessionStore.contacts;
         this.messageStore = base.sessionStore.messages;
+        this.messageSecretStore = base.sessionStore.messageSecret;
         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.preKeyStore = base.sessionStore.preKey;
+        this.sessionStore = base.sessionStore.session;
+        this.identityStore = base.sessionStore.identity;
         this.senderKeyStore = base.sessionStore.senderKey;
         this.threadStore = base.sessionStore.threads;
         this.writeBehind = new WriteBehindPersistence({
@@ -46,11 +52,16 @@ export class WaClient extends EventEmitter {
             threadStore: this.threadStore,
             contactStore: this.contactStore
         }, this.logger, this.options.writeBehind);
+        if (this.options.addons?.autoDecrypt &&
+            this.messageSecretStore === NOOP_MESSAGE_SECRET_STORE) {
+            this.logger.warn('addons.autoDecrypt is enabled but messageSecret cache is noop — ' +
+                'addon decryption will only work if secrets are in the message store');
+        }
         const dependencies = buildWaClientDependencies({
             base,
             runtime: {
                 sendNode: (node) => this.sendNode(node),
-                query: (node, timeoutMs) => this.query(node, timeoutMs),
+                query: (node, timeoutMs, options) => this.query(node, timeoutMs, options),
                 queryWithContext: this.queryWithContext.bind(this),
                 syncAppState: () => this.syncAppState().then(() => { }),
                 syncAppStateWithOptions: (syncOptions) => this.syncAppState(syncOptions),
@@ -109,12 +120,16 @@ export class WaClient extends EventEmitter {
             throw normalized;
         }
     }
-    async query(node, timeoutMs = this.options.iqTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS) {
+    async sendPresence(type) {
+        const credentials = this.authClient.getCurrentCredentials();
+        await this.nodeOrchestrator.sendNode(buildPresenceNode({ type, name: credentials?.meDisplayName ?? undefined }), false);
+    }
+    async query(node, timeoutMs = this.options.iqTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS, options = {}) {
         if (!this.connectionManager.isConnected()) {
             throw new Error('client is not connected');
         }
         this.logger.debug('wa client query', { tag: node.tag, id: node.attrs.id, timeoutMs });
-        return this.nodeOrchestrator.query(node, timeoutMs);
+        return this.nodeOrchestrator.query(node, timeoutMs, options);
     }
     registerIncomingHandler(registration) {
         return this.incomingNode.registerIncomingHandler(registration);
@@ -141,8 +156,17 @@ export class WaClient extends EventEmitter {
             void persistIncomingMailboxEntities({
                 logger: this.logger,
                 writeBehind: this.writeBehind,
+                messageSecretStore: this.messageSecretStore,
                 event
             });
+            if (this.options.addons?.autoDecrypt && event.message) {
+                void this.tryDecryptAddon(event).catch((err) => {
+                    this.logger.warn('addon auto-decrypt failed', {
+                        id: event.stanzaId,
+                        message: toError(err).message
+                    });
+                });
+            }
             const protocolMessage = event.message?.protocolMessage;
             if (!protocolMessage) {
                 return;
@@ -209,16 +233,6 @@ export class WaClient extends EventEmitter {
                 imported
             });
             if (imported > 0) {
-                const hadWaiters = this.keyShareCoordinator.hasWaiters();
-                this.keyShareCoordinator.notifyReceived();
-                if (hadWaiters) {
-                    this.logger.debug('app-state key share imported and waiters released', {
-                        id: event.stanzaId,
-                        from: event.chatJid,
-                        imported
-                    });
-                    return;
-                }
                 void this.syncAppState().catch((error) => {
                     this.logger.warn('failed to sync app-state after key share import', {
                         id: event.stanzaId,
@@ -359,8 +373,8 @@ export class WaClient extends EventEmitter {
             });
         }
     }
-    async queryWithContext(context, node, timeoutMs = this.options.iqTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS, contextData = {}) {
-        return queryNodeWithContext(async (queryNode, queryTimeoutMs) => this.query(queryNode, queryTimeoutMs), this.logger, context, node, timeoutMs, contextData);
+    async queryWithContext(context, node, timeoutMs = this.options.iqTimeoutMs ?? WA_DEFAULTS.IQ_TIMEOUT_MS, contextData = {}, options = {}) {
+        return queryNodeWithContext(async (queryNode, queryTimeoutMs) => this.query(queryNode, queryTimeoutMs, options), this.logger, context, node, timeoutMs, contextData);
     }
     async handleIncomingFrame(frame) {
         try {
@@ -400,7 +414,6 @@ export class WaClient extends EventEmitter {
                 remaining: writeBehindFlush.remaining
             });
         }
-        this.keyShareCoordinator.notifyDisconnected();
         await this.connectionManager.disconnect();
         this.emit('connection', {
             status: 'close',
@@ -410,12 +423,12 @@ export class WaClient extends EventEmitter {
             isNewLogin: false
         });
     }
-    async requestPairingCode(phoneNumber, shouldShowPushNotification = false) {
+    async requestPairingCode(phoneNumber, shouldShowPushNotification = false, customCode) {
         if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
             throw new Error('client is not connected');
         }
         this.logger.debug('wa client request pairing code');
-        return this.authClient.requestPairingCode(phoneNumber, shouldShowPushNotification);
+        return this.authClient.requestPairingCode(phoneNumber, shouldShowPushNotification, customCode);
     }
     async fetchPairingCountryCodeIso() {
         if (!this.connectionManager.isConnected() || !this.authClient.getCurrentCredentials()) {
@@ -464,6 +477,22 @@ export class WaClient extends EventEmitter {
     get business() {
         return this.businessCoordinator;
     }
+    get email() {
+        return this.emailCoordinator;
+    }
+    async logout(reason = WA_LOGOUT_REASONS.USER_INITIATED) {
+        const meJid = this.authClient.getCurrentCredentials()?.meJid;
+        if (!meJid) {
+            throw new Error('cannot logout: client is not authenticated');
+        }
+        const deviceJid = normalizeDeviceJid(meJid);
+        const node = buildRemoveCompanionDeviceIq(deviceJid, reason);
+        const result = await this.queryWithContext('client.logout', node, undefined, {
+            jid: deviceJid,
+            reason
+        });
+        assertIqResult(result, 'client.logout');
+    }
     sendReceipt(input) {
         return this.messageDispatch.sendReceipt(input);
     }
@@ -480,60 +509,11 @@ export class WaClient extends EventEmitter {
         if (!this.connectionManager.isConnected()) {
             throw new Error('client is not connected');
         }
-        const shouldWaitForKeyShare = (await this.appStateStore.getActiveSyncKey()) === null;
-        if (shouldWaitForKeyShare && !this.keyShareCoordinator.isBootstrapDone()) {
-            this.keyShareCoordinator.markBootstrapDone();
-            this.logger.info('app-state bootstrap pre-sync waiting for key share', {
-                timeoutMs: WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS
-            });
-            const received = await this.keyShareCoordinator.waitForShare(WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS);
-            if (received) {
-                this.logger.info('app-state bootstrap pre-sync received key share, continuing sync');
-            }
-            else {
-                this.logger.warn('app-state bootstrap pre-sync key share wait timed out, continuing sync', {
-                    timeoutMs: WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS
-                });
-            }
-        }
-        let syncResult = await this.executeAppStateSync(options);
-        let blockedCollections = this.getBlockedAppStateCollections(syncResult);
-        if (!shouldWaitForKeyShare || blockedCollections.length === 0) {
-            this.emitChatEventsFromAppStateSyncResult(syncResult);
-            return syncResult;
-        }
-        let retryCount = 0;
-        let observedKeyShareVersion = this.keyShareCoordinator.getVersion();
-        while (blockedCollections.length > 0 && retryCount < WA_APP_STATE_KEY_SHARE_MAX_RETRIES) {
-            const hasFreshShare = this.keyShareCoordinator.getVersion() !== observedKeyShareVersion;
-            if (!hasFreshShare) {
-                this.logger.info('app-state bootstrap waiting for key share', {
-                    blockedCollections: blockedCollections.join(','),
-                    timeoutMs: WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS,
-                    retryCount: retryCount + 1
-                });
-                const received = await this.keyShareCoordinator.waitForShare(WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS);
-                if (!received) {
-                    this.logger.warn('app-state bootstrap key share wait timed out', {
-                        blockedCollections: blockedCollections.join(','),
-                        timeoutMs: WA_APP_STATE_KEY_SHARE_WAIT_TIMEOUT_MS
-                    });
-                    break;
-                }
-            }
-            observedKeyShareVersion = this.keyShareCoordinator.getVersion();
-            retryCount += 1;
-            this.logger.info('app-state bootstrap retrying sync after key share', {
-                retryCount,
-                blockedCollections: blockedCollections.join(',')
-            });
-            syncResult = await this.executeAppStateSync(options);
-            blockedCollections = this.getBlockedAppStateCollections(syncResult);
-        }
+        const syncResult = await this.executeAppStateSync(options);
+        const blockedCollections = this.getBlockedAppStateCollections(syncResult);
         if (blockedCollections.length > 0) {
-            this.logger.warn('app-state bootstrap still blocked after waiting for key share', {
-                blockedCollections: blockedCollections.join(','),
-                retries: retryCount
+            this.logger.warn('app-state sync has blocked collections', {
+                blockedCollections: blockedCollections.join(',')
             });
         }
         this.emitChatEventsFromAppStateSyncResult(syncResult);
@@ -634,6 +614,8 @@ export class WaClient extends EventEmitter {
             await this.contactStore.clear();
         if (shouldClear('messages'))
             await this.messageStore.clear();
+        if (shouldClear('messageSecret'))
+            await this.messageSecretStore.clear();
         if (shouldClear('participants'))
             await this.participantsStore.clear();
         if (shouldClear('deviceList'))
@@ -642,6 +624,12 @@ export class WaClient extends EventEmitter {
             await this.retryStore.clear();
         if (shouldClear('signal'))
             await this.signalStore.clear();
+        if (shouldClear('preKey'))
+            await this.preKeyStore.clear();
+        if (shouldClear('session'))
+            await this.sessionStore.clear();
+        if (shouldClear('identity'))
+            await this.identityStore.clear();
         if (shouldClear('senderKey'))
             await this.senderKeyStore.clear();
         if (shouldClear('threads'))
@@ -649,6 +637,58 @@ export class WaClient extends EventEmitter {
         if (shouldClear('privacyToken'))
             await this.privacyTokenStore.clear();
     }
+    async tryDecryptAddon(event) {
+        const message = event.message;
+        if (!message)
+            return;
+        const addon = identifyEncryptedAddon(message);
+        if (!addon)
+            return;
+        const targetMessageId = addon.targetMessageKey.id;
+        if (!targetMessageId)
+            return;
+        const parentEntry = await resolveParentMessageSecret(targetMessageId, this.messageSecretStore, this.messageStore);
+        if (!parentEntry) {
+            this.logger.debug('addon parent message secret not found', {
+                id: event.stanzaId,
+                targetId: targetMessageId
+            });
+            return;
+        }
+        const parentMsgOriginalSender = parentEntry.senderJid;
+        const modificationSender = event.senderJid ?? '';
+        const plaintext = await decryptAddonPayload({
+            messageSecret: parentEntry.secret,
+            stanzaId: targetMessageId,
+            parentMsgOriginalSender,
+            modificationSender,
+            modificationType: addon.modificationType,
+            ciphertext: addon.encPayload,
+            iv: addon.encIv,
+            additionalData: shouldUseAddonAdditionalData(addon.modificationType)
+                ? buildAddonAdditionalData(targetMessageId, modificationSender)
+                : undefined
+        });
+        let decrypted = decodeAddonPlaintext(addon.kind, plaintext);
+        if (decrypted.kind === 'poll_vote' && decrypted.pollVote.selectedOptions) {
+            const names = await resolvePollOptionNames(decrypted.pollVote.selectedOptions, targetMessageId, this.messageStore);
+            if (names) {
+                decrypted = { ...decrypted, selectedOptionNames: names };
+            }
+        }
+        const addonEvent = {
+            rawNode: event.rawNode,
+            stanzaId: event.stanzaId,
+            chatJid: event.chatJid,
+            stanzaType: event.stanzaType,
+            kind: addon.kind,
+            targetMessageId,
+            senderJid: modificationSender,
+            decrypted,
+            raw: message
+        };
+        this.emit('message_addon', addonEvent);
+    }
     tryEnterIncomingHandler() {
         if (!this.acceptingIncomingEvents) {
             return false;

package/dist/esm/client/WaClientFactory.js

@@ -1,13 +1,15 @@
 import { WaAppStateSyncClient } from '../appstate/WaAppStateSyncClient.js';
 import { WaAuthClient } from '../auth/WaAuthClient.js';
 import { WaConnectionManager } from './connection/WaConnectionManager.js';
-import { WaKeyShareCoordinator } from './connection/WaKeyShareCoordinator.js';
 import { WaReceiptQueue } from './connection/WaReceiptQueue.js';
+import { WaAbPropsCoordinator } from './coordinators/WaAbPropsCoordinator.js';
 import { WaAppStateMutationCoordinator } from './coordinators/WaAppStateMutationCoordinator.js';
 import { createBusinessCoordinator } from './coordinators/WaBusinessCoordinator.js';
+import { createEmailCoordinator } from './coordinators/WaEmailCoordinator.js';
 import { createGroupCoordinator } from './coordinators/WaGroupCoordinator.js';
 import { WaIncomingNodeCoordinator } from './coordinators/WaIncomingNodeCoordinator.js';
 import { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator.js';
+import { WaOfflineResumeCoordinator } from './coordinators/WaOfflineResumeCoordinator.js';
 import { WaPassiveTasksCoordinator } from './coordinators/WaPassiveTasksCoordinator.js';
 import { createPrivacyCoordinator } from './coordinators/WaPrivacyCoordinator.js';
 import { createProfileCoordinator } from './coordinators/WaProfileCoordinator.js';
@@ -39,11 +41,12 @@ import { createSignalSessionResolver } from '../signal/session/resolver.js';
 import { SignalProtocol } from '../signal/session/SignalProtocol.js';
 import { WaKeepAlive } from '../transport/keepalive/WaKeepAlive.js';
 import { buildAckNode } from '../transport/node/builders/global.js';
+import { buildPresenceNode } from '../transport/node/builders/presence.js';
 import { getFirstNodeChild } from '../transport/node/helpers.js';
 import { createUsyncSidGenerator } from '../transport/node/usync.js';
 import { WaNodeOrchestrator } from '../transport/node/WaNodeOrchestrator.js';
 import { WaNodeTransport } from '../transport/node/WaNodeTransport.js';
-import { isProxyTransport, toProxyAgent, toProxyDispatcher } from '../transport/proxy.js';
+import { isProxyTransport, toProxyAgent } from '../transport/proxy.js';
 import { toError } from '../util/primitives.js';
 import { getRuntimeOsDisplayName } from '../util/runtime.js';
 function assertProxyTransport(value, path) {
@@ -128,6 +131,8 @@ function createIncomingNodeRuntime(input) {
         emitIncomingFailure: (event) => emitEvent('failure', event),
         emitIncomingErrorStanza: (event) => emitEvent('stanza_error', event),
         emitIncomingNotification: (event) => emitEvent('notification', event),
+        emitRegistrationCode: (event) => emitEvent('registration_code_received', event),
+        emitAccountTakeoverNotice: (event) => emitEvent('account_takeover_notice', event),
         emitGroupEvent: (event) => {
             emitEvent('group_event', event);
             void messageDispatch.mutateParticipantsCacheFromGroupEvent(event).catch((error) => {
@@ -151,7 +156,7 @@ function createIncomingNodeRuntime(input) {
     };
 }
 function createPassiveTasksRuntime(input) {
-    const { queryWithContext, authClient, nodeOrchestrator, receiptQueue, getCurrentCredentials } = input;
+    const { queryWithContext, authClient, nodeOrchestrator, receiptQueue, getCurrentCredentials, abPropsCoordinator } = input;
     return {
         queryWithContext,
         getCurrentCredentials,
@@ -159,14 +164,18 @@ function createPassiveTasksRuntime(input) {
         sendNodeDirect: (node) => nodeOrchestrator.sendNode(node),
         takeDanglingReceipts: () => receiptQueue.take(),
         requeueDanglingReceipt: (node) => receiptQueue.enqueue(node),
-        shouldQueueDanglingReceipt: (node, error) => receiptQueue.shouldQueue(node, error)
+        shouldQueueDanglingReceipt: (node, error) => receiptQueue.shouldQueue(node, error),
+        syncAbProps: () => abPropsCoordinator.sync(),
+        sendPresenceAvailable: async () => {
+            const credentials = getCurrentCredentials();
+            await nodeOrchestrator.sendNode(buildPresenceNode({ name: credentials?.meDisplayName ?? undefined }), false);
+        }
     };
 }
 export function buildWaClientDependencies(input) {
     const { base, runtime } = input;
     const { options, logger, sessionStore } = base;
     const receiptQueue = new WaReceiptQueue();
-    const keyShareCoordinator = new WaKeyShareCoordinator();
     let connectionManager = null;
     let passiveTasks = null;
     let mediaConnCacheFallback = null;
@@ -176,23 +185,24 @@ export function buildWaClientDependencies(input) {
         sendNode: async (node) => nodeTransport.sendNode(node),
         logger,
         defaultTimeoutMs: options.nodeQueryTimeoutMs,
-        hostDomain: WA_DEFAULTS.HOST_DOMAIN
+        hostDomain: WA_DEFAULTS.HOST_DOMAIN,
+        mobileIqIdFormat: options.mobileTransport !== undefined
     });
     const keepAlive = new WaKeepAlive({
         logger,
         nodeOrchestrator,
         getComms: () => connectionManager?.getComms() ?? null,
         intervalMs: options.keepAliveIntervalMs,
+        getIntervalMs: () => abPropsCoordinator.getConfigValue('heartbeat_interval_s') * 1000,
         timeoutMs: options.deadSocketTimeoutMs,
         hostDomain: WA_DEFAULTS.HOST_DOMAIN
     });
     const mediaTransfer = new WaMediaTransferClient({
         logger,
         defaultTimeoutMs: options.mediaTimeoutMs,
-        defaultUploadDispatcher: toProxyDispatcher(options.proxy?.mediaUpload),
-        defaultDownloadDispatcher: toProxyDispatcher(options.proxy?.mediaDownload),
         defaultUploadAgent: toProxyAgent(options.proxy?.mediaUpload),
-        defaultDownloadAgent: toProxyAgent(options.proxy?.mediaDownload)
+        defaultDownloadAgent: toProxyAgent(options.proxy?.mediaDownload),
+        skipMacVerification: options.dangerous?.disableMediaMacVerification
     });
     const mediaMessageBuildOptions = {
         logger,
@@ -208,7 +218,8 @@ export function buildWaClientDependencies(input) {
         setMediaConnCache: (mediaConn) => {
             mediaConnCacheFallback = mediaConn;
             connectionManager?.setMediaConnCache(mediaConn);
-        }
+        },
+        media: options.media
     };
     const messageClient = new WaMessageClient({
         logger,
@@ -218,12 +229,22 @@ export function buildWaClientDependencies(input) {
         defaultMaxAttempts: options.messageMaxAttempts,
         defaultRetryDelayMs: options.messageRetryDelayMs
     });
-    const senderKeyManager = new SenderKeyManager(sessionStore.senderKey);
-    const signalProtocol = new SignalProtocol(sessionStore.signal, logger);
+    const senderKeyManager = new SenderKeyManager(sessionStore.senderKey, {
+        getFutureMessagesMax: () => abPropsCoordinator.getConfigValue('web_signal_future_messages_max'),
+        skipSignatureVerification: options.dangerous?.disableSenderKeySignatureVerification
+    });
+    const signalProtocol = new SignalProtocol({
+        signal: sessionStore.signal,
+        preKey: sessionStore.preKey,
+        session: sessionStore.session,
+        identity: sessionStore.identity
+    }, logger);
+    const signalSystemQuery = (node, timeoutMs) => runtime.query(node, timeoutMs, { useSystemId: true });
     const signalDigestSync = new SignalDigestSyncApi({
         logger,
-        query: runtime.query,
+        query: signalSystemQuery,
         signalStore: sessionStore.signal,
+        preKeyStore: sessionStore.preKey,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const generateUsyncSid = createUsyncSidGenerator();
@@ -236,24 +257,24 @@ export function buildWaClientDependencies(input) {
     });
     const signalIdentitySync = new SignalIdentitySyncApi({
         logger,
-        query: runtime.query,
-        signalStore: sessionStore.signal,
+        query: signalSystemQuery,
+        identityStore: sessionStore.identity,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const signalMissingPreKeysSync = new SignalMissingPreKeysSyncApi({
         logger,
-        query: runtime.query,
+        query: signalSystemQuery,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const signalRotateKey = new SignalRotateKeyApi({
         logger,
-        query: runtime.query,
+        query: signalSystemQuery,
         signalStore: sessionStore.signal,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const signalSessionSync = new SignalSessionSyncApi({
         logger,
-        query: runtime.query,
+        query: signalSystemQuery,
         defaultTimeoutMs: options.signalFetchKeyBundlesTimeoutMs
     });
     const authClient = new WaAuthClient({
@@ -261,11 +282,14 @@ export function buildWaClientDependencies(input) {
         deviceOsDisplayName: options.deviceOsDisplayName,
         devicePlatform: options.devicePlatform,
         requireFullSync: options.requireFullSync,
-        version: options.version
+        version: options.version,
+        dangerous: options.dangerous,
+        mobileTransport: options.mobileTransport
     }, {
         logger,
         authStore: sessionStore.auth,
         signalStore: sessionStore.signal,
+        preKeyStore: sessionStore.preKey,
         socket: {
             sendNode: runtime.sendNode,
             query: runtime.query
@@ -298,13 +322,17 @@ export function buildWaClientDependencies(input) {
     const businessCoordinator = createBusinessCoordinator({
         queryWithContext: runtime.queryWithContext
     });
+    const emailCoordinator = createEmailCoordinator({
+        queryWithContext: runtime.queryWithContext
+    });
     const retryTracker = createOutboundRetryTracker({
         retryStore: sessionStore.retry,
         logger
     });
     const sessionResolver = createSignalSessionResolver({
         signalProtocol,
-        signalStore: sessionStore.signal,
+        sessionStore: sessionStore.session,
+        identityStore: sessionStore.identity,
         signalIdentitySync,
         signalSessionSync,
         logger
@@ -339,7 +367,19 @@ export function buildWaClientDependencies(input) {
         numBuckets: options.privacyToken?.tcTokenNumBuckets,
         senderDurationS: options.privacyToken?.tcTokenSenderDurationS,
         senderNumBuckets: options.privacyToken?.tcTokenSenderNumBuckets,
-        maxDurationS: options.privacyToken?.tcTokenMaxDurationS
+        maxDurationS: options.privacyToken?.tcTokenMaxDurationS,
+        getConfigOverrides: () => ({
+            durationS: abPropsCoordinator.getConfigValue('tctoken_duration'),
+            numBuckets: abPropsCoordinator.getConfigValue('tctoken_num_buckets'),
+            senderDurationS: abPropsCoordinator.getConfigValue('tctoken_duration_sender'),
+            senderNumBuckets: abPropsCoordinator.getConfigValue('tctoken_num_buckets_sender')
+        })
+    });
+    const abPropsCoordinator = new WaAbPropsCoordinator({
+        logger,
+        runtime: {
+            queryWithContext: runtime.queryWithContext
+        }
     });
     let messageDispatch;
     const appStateSyncKeyProtocol = createAppStateSyncKeyProtocol({
@@ -361,7 +401,10 @@ export function buildWaClientDependencies(input) {
         senderKeyManager,
         signalProtocol,
         signalStore: sessionStore.signal,
+        sessionStore: sessionStore.session,
+        identityStore: sessionStore.identity,
         deviceListStore: sessionStore.deviceList,
+        messageSecretStore: sessionStore.messageSecret,
         getCurrentMeJid,
         getCurrentMeLid,
         getCurrentSignedIdentity,
@@ -371,12 +414,16 @@ export function buildWaClientDependencies(input) {
                 to: recipientJid,
                 message: toError(err).message
             }));
-        }
+        },
+        getIcdcHashLength: () => abPropsCoordinator.getConfigValue('md_icdc_hash_length'),
+        mobileMessageIdFormat: options.mobileTransport !== undefined
     });
     const retryCoordinator = new WaRetryCoordinator({
         logger,
         retryStore: sessionStore.retry,
         signalStore: sessionStore.signal,
+        preKeyStore: sessionStore.preKey,
+        sessionStore: sessionStore.session,
         senderKeyStore: sessionStore.senderKey,
         signalProtocol,
         signalDeviceSync,
@@ -395,7 +442,9 @@ export function buildWaClientDependencies(input) {
         store: sessionStore.appState,
         onMissingKeys: async ({ keyIds }) => {
             await messageDispatch.requestAppStateSyncKeys(keyIds);
-        }
+        },
+        skipMacVerification: options.dangerous?.disableAppStateMacVerification,
+        mobilePrimary: options.mobileTransport !== undefined
     });
     const appStateMutations = new WaAppStateMutationCoordinator({
         logger,
@@ -417,7 +466,8 @@ export function buildWaClientDependencies(input) {
     }
     scheduleReconnectAfterPairing = () => connectionManager?.scheduleReconnectAfterPairing();
     const disconnectWithClientSideEffects = async (reason, isLogout, code) => {
-        keyShareCoordinator.notifyDisconnected();
+        abPropsCoordinator.reset();
+        offlineResume.reset();
         await connectionManager?.disconnect();
         runtime.emitEvent('connection', {
             status: 'close',
@@ -474,8 +524,16 @@ export function buildWaClientDependencies(input) {
         syncAppState: runtime.syncAppState,
         generateUsyncSid
     }, dirtyBits);
+    const offlineResume = new WaOfflineResumeCoordinator({
+        logger,
+        runtime: {
+            sendNode: (node) => nodeOrchestrator.sendNode(node, false),
+            emitOfflineResume: (event) => runtime.emitEvent('offline_resume', event)
+        }
+    });
     const incomingNode = new WaIncomingNodeCoordinator({
         logger,
+        offlineResume,
         runtime: createIncomingNodeRuntime({
             logger,
             emitEvent: runtime.emitEvent,
@@ -578,12 +636,12 @@ export function buildWaClientDependencies(input) {
                         return true;
                     }
                 }
-                const oldIdentity = await sessionStore.signal.getRemoteIdentity(address);
+                const oldIdentity = await sessionStore.identity.getRemoteIdentity(address);
                 if (oldIdentity) {
                     logger.info('identity-change: clearing session', {
                         jid: parsed.fromJid
                     });
-                    await sessionStore.signal.deleteSession(address);
+                    await sessionStore.session.deleteSession(address);
                     const userJid = toUserJid(parsed.fromJid);
                     await trustedContactToken.reissueOnIdentityChange(userJid).catch((error) => {
                         logger.warn('identity-change: reissue tc token failed', {
@@ -634,7 +692,7 @@ export function buildWaClientDependencies(input) {
                         server: baseAddress.server,
                         device: device.deviceId
                     };
-                    await sessionStore.signal.deleteSession(address).catch((error) => {
+                    await sessionStore.session.deleteSession(address).catch((error) => {
                         logger.warn('devices-notification: delete session failed', {
                             message: toError(error).message
                         });
@@ -696,9 +754,30 @@ export function buildWaClientDependencies(input) {
             return true;
         }
     });
+    // AB Props: sync after successful login and on server notification
+    incomingNode.registerIncomingHandler({
+        tag: WA_NODE_TAGS.NOTIFICATION,
+        subtype: WA_NOTIFICATION_TYPES.SERVER,
+        prepend: true,
+        handler: async (node) => {
+            const firstChild = getFirstNodeChild(node);
+            if (!firstChild || firstChild.tag !== WA_NODE_TAGS.ABPROPS) {
+                return false;
+            }
+            const ackNode = buildAckNode({
+                kind: 'notification',
+                node,
+                includeType: false
+            });
+            await runtime.sendNode(ackNode);
+            abPropsCoordinator.sync();
+            return true;
+        }
+    });
     passiveTasks = new WaPassiveTasksCoordinator({
         logger,
         signalStore: sessionStore.signal,
+        preKeyStore: sessionStore.preKey,
         signalDigestSync,
         signalRotateKey,
         runtime: createPassiveTasksRuntime({
@@ -706,8 +785,11 @@ export function buildWaClientDependencies(input) {
             authClient,
             nodeOrchestrator,
             receiptQueue,
-            getCurrentCredentials
-        })
+            getCurrentCredentials,
+            abPropsCoordinator
+        }),
+        mobilePrimary: options.mobileTransport !== undefined,
+        appStateSync
     });
     return {
         nodeTransport,
@@ -736,9 +818,10 @@ export function buildWaClientDependencies(input) {
         privacyCoordinator,
         profileCoordinator,
         businessCoordinator,
+        emailCoordinator,
         receiptQueue,
-        keyShareCoordinator,
         connectionManager,
-        trustedContactToken
+        trustedContactToken,
+        abPropsCoordinator
     };
 }