zapo-js 0.2.0 → 0.3.0

package/dist/client/coordinators/WaIncomingNodeCoordinator.js

@@ -6,7 +6,7 @@ const constants_1 = require("../../protocol/constants");
 const helpers_1 = require("../../transport/node/helpers");
 const parse_1 = require("../../transport/stream/parse");
 const primitives_1 = require("../../util/primitives");
-const INFO_BULLETIN_NOTIFICATION_TYPES = new Set([
+const INFO_BULLETIN_CHILD_TAGS = new Set([
     'offline',
     'offline_preview',
     'priority_offline_complete',
@@ -18,6 +18,7 @@ class WaIncomingNodeCoordinator {
     constructor(options) {
         this.logger = options.logger;
         this.runtime = options.runtime;
+        this.offlineResume = options.offlineResume;
         this.nodeHandlerRegistry = new Map();
         this.registerDefaultIncomingHandlers();
         this.mediaConnWarmupPromise = null;
@@ -28,6 +29,9 @@ class WaIncomingNodeCoordinator {
             id: node.attrs.id,
             type: node.attrs.type
         });
+        if (node.attrs.offline !== undefined) {
+            this.offlineResume.trackOfflineStanza();
+        }
         const streamControlResult = (0, parse_1.parseStreamControlNode)(node);
         if (streamControlResult) {
             await this.runtime.handleStreamControlResult(streamControlResult);
@@ -147,6 +151,16 @@ class WaIncomingNodeCoordinator {
                 emitUnhandledStanza: runtime.emitUnhandledIncomingNode
             })
         });
+        this.registerIncomingHandler({
+            tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
+            subtype: constants_1.WA_NOTIFICATION_TYPES.REGISTRATION,
+            handler: (0, incoming_1.createIncomingRegistrationNotificationHandler)({
+                logger: this.logger,
+                sendNode: runtime.sendNode,
+                emitRegistrationCode: runtime.emitRegistrationCode,
+                emitAccountTakeoverNotice: runtime.emitAccountTakeoverNotice
+            })
+        });
         this.registerIncomingHandler({
             tag: constants_1.WA_NODE_TAGS.NOTIFICATION,
             handler: (0, incoming_1.createIncomingNotificationHandler)({
@@ -266,13 +280,24 @@ class WaIncomingNodeCoordinator {
             return false;
         }
         let handled = false;
-        const ibType = node.attrs.type;
-        if (ibType && INFO_BULLETIN_NOTIFICATION_TYPES.has(ibType)) {
-            this.runtime.emitIncomingNotification((0, incoming_1.createInfoBulletinNotificationEvent)(node, ibType, {
-                count: (0, primitives_1.parseOptionalInt)(node.attrs.count),
-                t: (0, primitives_1.parseOptionalInt)(node.attrs.t)
-            }));
-            handled = true;
+        const children = (0, helpers_1.getNodeChildren)(node);
+        for (const child of children) {
+            if (INFO_BULLETIN_CHILD_TAGS.has(child.tag)) {
+                this.runtime.emitIncomingNotification((0, incoming_1.createInfoBulletinNotificationEvent)(node, child.tag, {
+                    count: (0, primitives_1.parseOptionalInt)(child.attrs.count),
+                    message: (0, primitives_1.parseOptionalInt)(child.attrs.message),
+                    receipt: (0, primitives_1.parseOptionalInt)(child.attrs.receipt),
+                    notification: (0, primitives_1.parseOptionalInt)(child.attrs.notification),
+                    t: (0, primitives_1.parseOptionalInt)(child.attrs.t)
+                }));
+                if (child.tag === 'offline_preview') {
+                    this.offlineResume.handleOfflinePreview((0, primitives_1.parseOptionalInt)(child.attrs.count) ?? 0);
+                }
+                if (child.tag === 'offline') {
+                    this.offlineResume.handleOfflineComplete((0, primitives_1.parseOptionalInt)(child.attrs.count) ?? 0);
+                }
+                handled = true;
+            }
         }
         const edgeRoutingNode = (0, helpers_1.findNodeChild)(node, constants_1.WA_NODE_TAGS.EDGE_ROUTING);
         if (edgeRoutingNode) {

package/dist/client/coordinators/WaMessageDispatchCoordinator.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaMessageDispatchCoordinator = void 0;
 const _crypto_1 = require("../../crypto/index.js");
+const primitives_1 = require("../../crypto/core/primitives");
 const PromiseDedup_1 = require("../../infra/perf/PromiseDedup");
 const _message_1 = require("../../message/index.js");
 const content_1 = require("../../message/content");
@@ -13,11 +14,10 @@ const reporting_token_1 = require("../../message/reporting-token");
 const _proto_1 = require("../../proto.js");
 const constants_1 = require("../../protocol/constants");
 const jid_1 = require("../../protocol/jid");
-const jid_2 = require("../../protocol/jid");
 const binary_1 = require("../../transport/binary");
 const message_1 = require("../../transport/node/builders/message");
 const bytes_1 = require("../../util/bytes");
-const primitives_1 = require("../../util/primitives");
+const primitives_2 = require("../../util/primitives");
 class WaMessageDispatchCoordinator {
     constructor(options) {
         this.icdcDedup = new PromiseDedup_1.PromiseDedup();
@@ -34,12 +34,17 @@ class WaMessageDispatchCoordinator {
         this.senderKeyManager = options.senderKeyManager;
         this.signalProtocol = options.signalProtocol;
         this.signalStore = options.signalStore;
+        this.sessionStore = options.sessionStore;
+        this.identityStore = options.identityStore;
         this.deviceListStore = options.deviceListStore;
+        this.messageSecretStore = options.messageSecretStore;
         this.getCurrentMeJid = options.getCurrentMeJid;
         this.getCurrentMeLid = options.getCurrentMeLid;
         this.getCurrentSignedIdentity = options.getCurrentSignedIdentity;
         this.resolvePrivacyTokenNode = options.resolvePrivacyTokenNode;
         this.onDirectMessageSent = options.onDirectMessageSent;
+        this.getIcdcHashLength = options.getIcdcHashLength;
+        this.mobileMessageIdFormat = options.mobileMessageIdFormat ?? false;
     }
     async publishMessageNode(node, options = {}) {
         this.logger.debug('wa client publish message node', {
@@ -132,6 +137,21 @@ class WaMessageDispatchCoordinator {
             this.withResolvedMessageId(options)
         ]);
         const messageWithSecret = await (0, _message_1.ensureMessageSecret)(message);
+        const rawSecret = messageWithSecret.messageContextInfo?.messageSecret;
+        if (rawSecret &&
+            rawSecret.length > 0 &&
+            sendOptions.id &&
+            (0, content_1.needsSecretPersistence)(messageWithSecret)) {
+            const meJid = this.getCurrentMeJid() ?? '';
+            void this.messageSecretStore
+                .set(sendOptions.id, { secret: rawSecret, senderJid: meJid })
+                .catch((error) => {
+                this.logger.warn('failed to persist outgoing message secret', {
+                    id: sendOptions.id,
+                    message: (0, primitives_2.toError)(error).message
+                });
+            });
+        }
         const meJid = this.getCurrentMeJid();
         const regInfo = meJid ? await this.signalStore.getRegistrationInfo() : null;
         const localPubKey = regInfo?.identityKeyPair.pubKey;
@@ -378,7 +398,7 @@ class WaMessageDispatchCoordinator {
             this.logger.warn('failed to mark sender key distribution targets', {
                 groupJid,
                 participants: distributedAddresses.length,
-                message: (0, primitives_1.toError)(error).message
+                message: (0, primitives_2.toError)(error).message
             });
         }
         const ackError = result.ack.error;
@@ -411,14 +431,8 @@ class WaMessageDispatchCoordinator {
     }
     resolveGroupAddressingMode(participantUserJids, groupJid) {
         for (let index = 0; index < participantUserJids.length; index += 1) {
-            const participantJid = participantUserJids[index];
-            try {
-                if ((0, jid_1.splitJid)(participantJid).server === 'lid') {
-                    return 'lid';
-                }
-            }
-            catch (error) {
-                this.logger.trace('ignoring malformed participant jid in addressing mode resolution', { participantJid, message: (0, primitives_1.toError)(error).message });
+            if ((0, jid_1.isLidJid)(participantUserJids[index])) {
+                return 'lid';
             }
         }
         this.logger.trace('group addressing mode resolved to pn (default)', {
@@ -437,7 +451,7 @@ class WaMessageDispatchCoordinator {
                 catch (error) {
                     this.logger.trace('ignoring malformed me lid jid', {
                         meLid,
-                        message: (0, primitives_1.toError)(error).message
+                        message: (0, primitives_2.toError)(error).message
                     });
                 }
             }
@@ -461,7 +475,7 @@ class WaMessageDispatchCoordinator {
             const jid = fanoutDeviceJids[index];
             const address = (0, jid_1.parseSignalAddressFromJid)(jid);
             fanoutAddresses[index] = address;
-            fanoutTargetsByAddressKey.set((0, jid_2.signalAddressKey)(address), { jid, address });
+            fanoutTargetsByAddressKey.set((0, jid_1.signalAddressKey)(address), { jid, address });
         }
         const pendingAddresses = await this.senderKeyManager.filterParticipantsNeedingDistribution(groupJid, senderKeyId, fanoutAddresses);
         if (pendingAddresses.length === 0) {
@@ -473,7 +487,7 @@ class WaMessageDispatchCoordinator {
         const pendingAddressKeys = new Set();
         const pendingTargets = [];
         for (let index = 0; index < pendingAddresses.length; index += 1) {
-            const key = (0, jid_2.signalAddressKey)(pendingAddresses[index]);
+            const key = (0, jid_1.signalAddressKey)(pendingAddresses[index]);
             if (pendingAddressKeys.has(key)) {
                 continue;
             }
@@ -501,7 +515,7 @@ class WaMessageDispatchCoordinator {
             prefetchedAvailableTargets = resolvedTargets;
         }
         catch (error) {
-            const normalized = (0, primitives_1.toError)(error);
+            const normalized = (0, primitives_2.toError)(error);
             if (normalized.message === 'identity mismatch') {
                 throw normalized;
             }
@@ -514,7 +528,7 @@ class WaMessageDispatchCoordinator {
             for (let index = 0; index < pendingTargets.length; index += 1) {
                 pendingTargetAddresses[index] = pendingTargets[index].address;
             }
-            const hasPendingSessions = await this.signalStore.hasSessions(pendingTargetAddresses);
+            const hasPendingSessions = await this.sessionStore.hasSessions(pendingTargetAddresses);
             const nextAvailableTargets = [];
             for (let index = 0; index < pendingTargets.length; index += 1) {
                 if (hasPendingSessions[index]) {
@@ -672,7 +686,7 @@ class WaMessageDispatchCoordinator {
         catch (error) {
             this.logger.warn('privacy token resolution failed', {
                 to: recipientUserJid,
-                message: (0, primitives_1.toError)(error).message
+                message: (0, primitives_2.toError)(error).message
             });
         }
         const messageNode = (0, message_1.buildDirectMessageFanoutNode)({
@@ -722,9 +736,20 @@ class WaMessageDispatchCoordinator {
     async generateOutgoingMessageId() {
         try {
             const meUserJid = (0, jid_1.toUserJid)(this.requireCurrentMeJid('sendMessage'));
-            const timestampSeconds = Math.floor(Date.now() / 1000);
             const timestampBytes = new Uint8Array(8);
-            new DataView(timestampBytes.buffer, timestampBytes.byteOffset, timestampBytes.byteLength).setBigUint64(0, BigInt(timestampSeconds), false);
+            const dv = new DataView(timestampBytes.buffer, timestampBytes.byteOffset, timestampBytes.byteLength);
+            if (this.mobileMessageIdFormat) {
+                dv.setBigUint64(0, BigInt(Date.now()), false);
+                const entropy = (0, bytes_1.concatBytes)([
+                    timestampBytes,
+                    bytes_1.TEXT_ENCODER.encode(meUserJid),
+                    await (0, _crypto_1.randomBytesAsync)(16)
+                ]);
+                const digest = (0, primitives_1.md5Bytes)(entropy);
+                digest[0] = 0xac;
+                return (0, bytes_1.bytesToHex)(digest).toUpperCase();
+            }
+            dv.setBigUint64(0, BigInt(Math.floor(Date.now() / 1000)), false);
             const entropy = (0, bytes_1.concatBytes)([
                 timestampBytes,
                 bytes_1.TEXT_ENCODER.encode(meUserJid),
@@ -734,9 +759,14 @@ class WaMessageDispatchCoordinator {
             return `3EB0${(0, bytes_1.bytesToHex)(digest.subarray(0, 9)).toUpperCase()}`;
         }
         catch (error) {
-            this.logger.warn('failed to generate sha256 message id, falling back to random id', {
-                message: (0, primitives_1.toError)(error).message
+            this.logger.warn('failed to generate message id, falling back to random', {
+                message: (0, primitives_2.toError)(error).message
             });
+            if (this.mobileMessageIdFormat) {
+                const bytes = await (0, _crypto_1.randomBytesAsync)(16);
+                bytes[0] = 0xac;
+                return (0, bytes_1.bytesToHex)(bytes).toUpperCase();
+            }
             return `3EB0${(0, bytes_1.bytesToHex)(await (0, _crypto_1.randomBytesAsync)(8)).toUpperCase()}`;
         }
     }
@@ -757,7 +787,7 @@ class WaMessageDispatchCoordinator {
                 context: input.context,
                 id: input.stanzaId,
                 remoteJid: input.remoteJid,
-                message: (0, primitives_1.toError)(error).message
+                message: (0, primitives_2.toError)(error).message
             });
             return null;
         }
@@ -765,7 +795,7 @@ class WaMessageDispatchCoordinator {
     getEncodedSignedDeviceIdentity() {
         const signedIdentity = this.getCurrentSignedIdentity();
         if (!signedIdentity) {
-            throw new Error('missing signed identity for pkmsg fanout');
+            return undefined;
         }
         return _proto_1.proto.ADVSignedDeviceIdentity.encode(signedIdentity).finish();
     }
@@ -777,12 +807,12 @@ class WaMessageDispatchCoordinator {
                 if (!snapshot || snapshot.deviceJids.length === 0) {
                     return null;
                 }
-                return (0, icdc_1.resolveIcdcMeta)(snapshot.deviceJids, this.signalStore, snapshot.updatedAtMs, localIdentity);
+                return (0, icdc_1.resolveIcdcMeta)(snapshot.deviceJids, this.identityStore, snapshot.updatedAtMs, localIdentity, this.getIcdcHashLength?.());
             }
             catch (error) {
                 this.logger.trace('icdc resolution failed', {
                     userJid,
-                    message: (0, primitives_1.toError)(error).message
+                    message: (0, primitives_2.toError)(error).message
                 });
                 return null;
             }

package/dist/client/coordinators/WaOfflineResumeCoordinator.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaOfflineResumeCoordinator = void 0;
+const offline_1 = require("../../transport/node/builders/offline");
+const primitives_1 = require("../../util/primitives");
+const WA_OFFLINE_RESUME = Object.freeze({
+    BATCH_SIZE: 200,
+    STANZA_TIMEOUT_MS: 60000
+});
+const WA_OFFLINE_RESUME_STATE = Object.freeze({
+    INIT: 'init',
+    RESUMING: 'resuming',
+    COMPLETE: 'complete'
+});
+class WaOfflineResumeCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.runtime = options.runtime;
+        this.state = WA_OFFLINE_RESUME_STATE.INIT;
+        this.totalStanzas = 0;
+        this.pendingStanzas = 0;
+        this.stanzaTimeout = null;
+    }
+    get isComplete() {
+        return this.state === WA_OFFLINE_RESUME_STATE.COMPLETE;
+    }
+    get isResuming() {
+        return this.state === WA_OFFLINE_RESUME_STATE.RESUMING;
+    }
+    handleOfflinePreview(stanzaCount) {
+        this.clearTimers();
+        this.state = WA_OFFLINE_RESUME_STATE.RESUMING;
+        this.totalStanzas = stanzaCount;
+        this.pendingStanzas = stanzaCount;
+        this.logger.info('offline resume started', {
+            totalStanzas: stanzaCount
+        });
+        this.runtime.emitOfflineResume({
+            status: 'resuming',
+            totalStanzas: stanzaCount,
+            remainingStanzas: stanzaCount,
+            forced: false
+        });
+        void this.sendOfflineBatch();
+        this.resetStanzaTimeout();
+    }
+    handleOfflineComplete(serverStanzaCount) {
+        if (this.state !== WA_OFFLINE_RESUME_STATE.RESUMING) {
+            return;
+        }
+        this.completeResume(false, serverStanzaCount);
+    }
+    trackOfflineStanza() {
+        if (this.state !== WA_OFFLINE_RESUME_STATE.RESUMING) {
+            return;
+        }
+        this.pendingStanzas = Math.max(0, this.pendingStanzas - 1);
+        this.resetStanzaTimeout();
+    }
+    reset() {
+        this.clearTimers();
+        this.state = WA_OFFLINE_RESUME_STATE.INIT;
+        this.totalStanzas = 0;
+        this.pendingStanzas = 0;
+    }
+    completeResume(forced, serverStanzaCount) {
+        this.clearTimers();
+        this.state = WA_OFFLINE_RESUME_STATE.COMPLETE;
+        this.logger.info('offline resume complete', {
+            totalStanzas: this.totalStanzas,
+            remainingStanzas: this.pendingStanzas,
+            serverStanzaCount,
+            forced
+        });
+        this.runtime.emitOfflineResume({
+            status: 'complete',
+            totalStanzas: this.totalStanzas,
+            remainingStanzas: this.pendingStanzas,
+            forced
+        });
+    }
+    async sendOfflineBatch() {
+        try {
+            await this.runtime.sendNode((0, offline_1.buildOfflineBatchNode)(WA_OFFLINE_RESUME.BATCH_SIZE));
+        }
+        catch (err) {
+            this.logger.warn('offline batch request failed', {
+                message: (0, primitives_1.toError)(err).message
+            });
+        }
+    }
+    resetStanzaTimeout() {
+        if (this.stanzaTimeout !== null) {
+            clearTimeout(this.stanzaTimeout);
+        }
+        this.stanzaTimeout = setTimeout(() => {
+            this.stanzaTimeout = null;
+            if (this.state === WA_OFFLINE_RESUME_STATE.RESUMING) {
+                this.logger.warn('offline resume forced complete due to stanza timeout', {
+                    totalStanzas: this.totalStanzas,
+                    remainingStanzas: this.pendingStanzas
+                });
+                this.completeResume(true);
+            }
+        }, WA_OFFLINE_RESUME.STANZA_TIMEOUT_MS);
+    }
+    clearTimers() {
+        if (this.stanzaTimeout !== null) {
+            clearTimeout(this.stanzaTimeout);
+            this.stanzaTimeout = null;
+        }
+    }
+}
+exports.WaOfflineResumeCoordinator = WaOfflineResumeCoordinator;

package/dist/client/coordinators/WaPassiveTasksCoordinator.js

@@ -10,6 +10,7 @@ class WaPassiveTasksCoordinator {
     constructor(options) {
         this.logger = options.logger;
         this.signalStore = options.signalStore;
+        this.preKeyStore = options.preKeyStore;
         this.signalDigestSync = options.signalDigestSync;
         this.signalRotateKey = options.signalRotateKey;
         this.signedPreKeyRotationIntervalMs =
@@ -17,6 +18,8 @@ class WaPassiveTasksCoordinator {
         this.signedPreKeyServerErrorBackoffMs =
             options.signedPreKeyServerErrorBackoffMs ?? constants_2.SIGNAL_SIGNED_PREKEY_SERVER_ERROR_BACKOFF_MS;
         this.runtime = options.runtime;
+        this.mobilePrimary = options.mobilePrimary ?? false;
+        this.appStateSync = options.appStateSync;
         this.passiveTasksPromise = null;
     }
     startPassiveTasksAfterConnect() {
@@ -36,7 +39,7 @@ class WaPassiveTasksCoordinator {
     }
     async handlePreKeyLowNotification() {
         await Promise.all([
-            this.signalStore.setServerHasPreKeys(false),
+            this.preKeyStore.setServerHasPreKeys(false),
             this.runtime.persistServerHasPreKeys(false)
         ]);
         await this.uploadPreKeysIfMissing(false);
@@ -57,11 +60,29 @@ class WaPassiveTasksCoordinator {
             this.logger.trace('passive connect tasks skipped: session is not registered');
             return;
         }
-        const signalMeta = await this.signalStore.getSignalMeta();
-        const prefetchedLocalKeyBundle = this.resolveLocalKeyBundle(signalMeta);
-        await this.uploadPreKeysIfMissing(signalMeta.serverHasPreKeys, prefetchedLocalKeyBundle);
+        this.runtime.syncAbProps();
+        if (this.mobilePrimary && this.appStateSync) {
+            await this.appStateSync.ensureInitialSyncKey().catch((error) => {
+                this.logger.warn('app-state initial key generation failed', {
+                    message: (0, primitives_1.toError)(error).message
+                });
+            });
+        }
+        await this.runtime.sendPresenceAvailable().catch((error) => {
+            this.logger.warn('presence available send failed', {
+                message: (0, primitives_1.toError)(error).message
+            });
+        });
+        const [registrationInfo, signedPreKey, serverHasPreKeys, signedPreKeyRotationTs] = await Promise.all([
+            this.signalStore.getRegistrationInfo(),
+            this.signalStore.getSignedPreKey(),
+            this.preKeyStore.getServerHasPreKeys(),
+            this.signalStore.getSignedPreKeyRotationTs()
+        ]);
+        const prefetchedLocalKeyBundle = registrationInfo && signedPreKey ? { registrationInfo, signedPreKey } : null;
+        await this.uploadPreKeysIfMissing(serverHasPreKeys, prefetchedLocalKeyBundle);
         await this.validateDigestAndRecoverPreKeys(prefetchedLocalKeyBundle);
-        await this.rotateSignedPreKeyIfDue(signalMeta.signedPreKeyRotationTs);
+        await this.rotateSignedPreKeyIfDue(signedPreKeyRotationTs);
         await this.flushDanglingReceipts();
     }
     async validateDigestAndRecoverPreKeys(prefetchedLocalKeyBundle) {
@@ -84,7 +105,7 @@ class WaPassiveTasksCoordinator {
                 return;
             }
             await Promise.all([
-                this.signalStore.setServerHasPreKeys(false),
+                this.preKeyStore.setServerHasPreKeys(false),
                 this.runtime.persistServerHasPreKeys(false)
             ]);
             await this.uploadPreKeysIfMissing(false, prefetchedLocalKeyBundle);
@@ -96,7 +117,7 @@ class WaPassiveTasksCoordinator {
         }
     }
     async uploadPreKeysIfMissing(serverHasPreKeysHint, prefetchedLocalKeyBundle) {
-        const serverHasPreKeys = serverHasPreKeysHint ?? (await this.signalStore.getServerHasPreKeys());
+        const serverHasPreKeys = serverHasPreKeysHint ?? (await this.preKeyStore.getServerHasPreKeys());
         if (serverHasPreKeys) {
             this.logger.trace('prekey upload skipped: server already has prekeys');
             return;
@@ -107,7 +128,7 @@ class WaPassiveTasksCoordinator {
             return;
         }
         const { registrationInfo, signedPreKey } = resolvedLocalKeyBundle;
-        const preKeys = await this.signalStore.getOrGenPreKeys(constants_2.SIGNAL_UPLOAD_PREKEYS_COUNT, keygen_1.generatePreKeyPair);
+        const preKeys = await this.preKeyStore.getOrGenPreKeys(constants_2.SIGNAL_UPLOAD_PREKEYS_COUNT, keygen_1.generatePreKeyPair);
         if (preKeys.length === 0) {
             throw new Error('no prekey available for upload');
         }
@@ -116,12 +137,12 @@ class WaPassiveTasksCoordinator {
         const response = await this.runtime.queryWithContext('prekeys.upload', uploadNode, constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, {
             count: preKeys.length,
             lastPreKeyId
-        });
+        }, this.mobilePrimary ? { useSystemId: true } : undefined);
         if (response.attrs.type === 'result') {
             // Mark uploaded key first so the serverHasPreKeys flag never commits ahead of local key progress.
-            await this.signalStore.markKeyAsUploaded(lastPreKeyId);
+            await this.preKeyStore.markKeyAsUploaded(lastPreKeyId);
             await Promise.all([
-                this.signalStore.setServerHasPreKeys(true),
+                this.preKeyStore.setServerHasPreKeys(true),
                 this.runtime.persistServerHasPreKeys(true)
             ]);
             this.logger.info('uploaded prekeys to server', {
@@ -168,18 +189,15 @@ class WaPassiveTasksCoordinator {
             });
         }
     }
-    resolveLocalKeyBundle(signalMeta) {
-        const { registrationInfo, signedPreKey } = signalMeta;
+    async resolveLocalKeyBundleFromStore() {
+        const [registrationInfo, signedPreKey] = await Promise.all([
+            this.signalStore.getRegistrationInfo(),
+            this.signalStore.getSignedPreKey()
+        ]);
         if (!registrationInfo || !signedPreKey) {
             return null;
         }
-        return {
-            registrationInfo,
-            signedPreKey
-        };
-    }
-    async resolveLocalKeyBundleFromStore() {
-        return this.resolveLocalKeyBundle(await this.signalStore.getSignalMeta());
+        return { registrationInfo, signedPreKey };
     }
     resolveRotationTimestamp(nowMs, errorCode) {
         if (errorCode !== undefined && errorCode >= 500) {

package/dist/client/coordinators/WaProfileCoordinator.js

@@ -175,7 +175,9 @@ function createProfileCoordinator(options) {
         },
         setStatus: async (text) => {
             const node = (0, profile_1.buildSetStatusIq)(text);
-            const result = await queryWithContext('profile.setStatus', node);
+            const result = await queryWithContext('profile.setStatus', node, undefined, undefined, {
+                useSystemId: true
+            });
             (0, query_1.assertIqResult)(result, 'profile.setStatus');
         },
         getProfiles: async (jids) => {

package/dist/client/coordinators/WaRetryCoordinator.js

@@ -40,6 +40,8 @@ class WaRetryCoordinator {
         this.retryStore = options.retryStore;
         this.retryTtlMs = this.retryStore.getTtlMs?.() ?? constants_2.RETRY_OUTBOUND_TTL_MS;
         this.signalStore = options.signalStore;
+        this.preKeyStore = options.preKeyStore;
+        this.sessionStore = options.sessionStore;
         this.senderKeyStore = options.senderKeyStore;
         this.signalProtocol = options.signalProtocol;
         this.signalDeviceSync = options.signalDeviceSync;
@@ -341,13 +343,13 @@ class WaRetryCoordinator {
     async buildRetryKeysSection(identity) {
         const [signedPreKey, preKey] = await Promise.all([
             this.signalStore.getSignedPreKey(),
-            this.signalStore.getOrGenSinglePreKey(keygen_1.generatePreKeyPair)
+            this.preKeyStore.getOrGenSinglePreKey(keygen_1.generatePreKeyPair)
         ]);
         if (!signedPreKey) {
             this.logger.warn('retry keys section skipped: signed prekey unavailable');
             return undefined;
         }
-        await this.signalStore.markKeyAsUploaded(preKey.keyId);
+        await this.preKeyStore.markKeyAsUploaded(preKey.keyId);
         const signedIdentity = this.getCurrentSignedIdentity();
         return {
             identity,
@@ -368,11 +370,11 @@ class WaRetryCoordinator {
     async updateLocalSessionFromRetryRequest(request, requesterJid, requesterAddress, requesterNormalizedDeviceJid) {
         const [, currentSession] = await Promise.all([
             this.markRetryRequesterSenderKeyAsStale(request, requesterJid, requesterAddress),
-            this.signalStore.getSession(requesterAddress)
+            this.sessionStore.getSession(requesterAddress)
         ]);
         const regIdMismatch = !!currentSession && request.regId > 0 && currentSession.remote.regId !== request.regId;
         if (regIdMismatch && !request.keyBundle) {
-            await this.signalStore.deleteSession(requesterAddress);
+            await this.sessionStore.deleteSession(requesterAddress);
         }
         if (request.keyBundle) {
             if (!request.keyBundle.key || !request.keyBundle.skey.signature) {
@@ -387,7 +389,7 @@ class WaRetryCoordinator {
                         remoteRetryCount: request.retryCount,
                         ...getRemoteRetryReasonLogFields(request.retryReason)
                     });
-                    await this.signalStore.deleteSession(requesterAddress);
+                    await this.sessionStore.deleteSession(requesterAddress);
                     return false;
                 }
                 if (regIdMismatch) {
@@ -398,12 +400,12 @@ class WaRetryCoordinator {
                         remoteRetryCount: request.retryCount,
                         ...getRemoteRetryReasonLogFields(request.retryReason)
                     });
-                    await this.signalStore.deleteSession(requesterAddress);
+                    await this.sessionStore.deleteSession(requesterAddress);
                     return false;
                 }
             }
             else if (regIdMismatch) {
-                await this.signalStore.deleteSession(requesterAddress);
+                await this.sessionStore.deleteSession(requesterAddress);
             }
             await this.signalProtocol.establishOutgoingSession(requesterAddress, {
                 regId: request.regId,
@@ -435,7 +437,7 @@ class WaRetryCoordinator {
         if (request.retryCount < 2) {
             return true;
         }
-        const currentSession = await this.signalStore.getSession(requesterAddress);
+        const currentSession = await this.sessionStore.getSession(requesterAddress);
         const sessionBaseKey = currentSession?.aliceBaseKey ?? null;
         if (!sessionBaseKey) {
             return true;
@@ -449,7 +451,7 @@ class WaRetryCoordinator {
         if (!saved || !(0, bytes_1.uint8Equal)(saved.baseKey, sessionBaseKey)) {
             return true;
         }
-        await this.signalStore.deleteSession(requesterAddress);
+        await this.sessionStore.deleteSession(requesterAddress);
         this.logger.info('retry request forcing session refresh due to repeated base key', {
             id: request.stanzaId,
             originalMsgId: request.originalMsgId,