zapo-js 0.2.0 → 0.3.0

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

@@ -7,6 +7,7 @@ export 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 =
@@ -14,6 +15,8 @@ export class WaPassiveTasksCoordinator {
         this.signedPreKeyServerErrorBackoffMs =
             options.signedPreKeyServerErrorBackoffMs ?? SIGNAL_SIGNED_PREKEY_SERVER_ERROR_BACKOFF_MS;
         this.runtime = options.runtime;
+        this.mobilePrimary = options.mobilePrimary ?? false;
+        this.appStateSync = options.appStateSync;
         this.passiveTasksPromise = null;
     }
     startPassiveTasksAfterConnect() {
@@ -33,7 +36,7 @@ export class WaPassiveTasksCoordinator {
     }
     async handlePreKeyLowNotification() {
         await Promise.all([
-            this.signalStore.setServerHasPreKeys(false),
+            this.preKeyStore.setServerHasPreKeys(false),
             this.runtime.persistServerHasPreKeys(false)
         ]);
         await this.uploadPreKeysIfMissing(false);
@@ -54,11 +57,29 @@ export 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: toError(error).message
+                });
+            });
+        }
+        await this.runtime.sendPresenceAvailable().catch((error) => {
+            this.logger.warn('presence available send failed', {
+                message: 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) {
@@ -81,7 +102,7 @@ export class WaPassiveTasksCoordinator {
                 return;
             }
             await Promise.all([
-                this.signalStore.setServerHasPreKeys(false),
+                this.preKeyStore.setServerHasPreKeys(false),
                 this.runtime.persistServerHasPreKeys(false)
             ]);
             await this.uploadPreKeysIfMissing(false, prefetchedLocalKeyBundle);
@@ -93,7 +114,7 @@ export 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;
@@ -104,7 +125,7 @@ export class WaPassiveTasksCoordinator {
             return;
         }
         const { registrationInfo, signedPreKey } = resolvedLocalKeyBundle;
-        const preKeys = await this.signalStore.getOrGenPreKeys(SIGNAL_UPLOAD_PREKEYS_COUNT, generatePreKeyPair);
+        const preKeys = await this.preKeyStore.getOrGenPreKeys(SIGNAL_UPLOAD_PREKEYS_COUNT, generatePreKeyPair);
         if (preKeys.length === 0) {
             throw new Error('no prekey available for upload');
         }
@@ -113,12 +134,12 @@ export class WaPassiveTasksCoordinator {
         const response = await this.runtime.queryWithContext('prekeys.upload', uploadNode, 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', {
@@ -165,18 +186,15 @@ export 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/esm/client/coordinators/WaProfileCoordinator.js

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

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

@@ -37,6 +37,8 @@ export class WaRetryCoordinator {
         this.retryStore = options.retryStore;
         this.retryTtlMs = this.retryStore.getTtlMs?.() ?? 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;
@@ -338,13 +340,13 @@ export class WaRetryCoordinator {
     async buildRetryKeysSection(identity) {
         const [signedPreKey, preKey] = await Promise.all([
             this.signalStore.getSignedPreKey(),
-            this.signalStore.getOrGenSinglePreKey(generatePreKeyPair)
+            this.preKeyStore.getOrGenSinglePreKey(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,
@@ -365,11 +367,11 @@ export 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) {
@@ -384,7 +386,7 @@ export class WaRetryCoordinator {
                         remoteRetryCount: request.retryCount,
                         ...getRemoteRetryReasonLogFields(request.retryReason)
                     });
-                    await this.signalStore.deleteSession(requesterAddress);
+                    await this.sessionStore.deleteSession(requesterAddress);
                     return false;
                 }
                 if (regIdMismatch) {
@@ -395,12 +397,12 @@ export 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,
@@ -432,7 +434,7 @@ export 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;
@@ -446,7 +448,7 @@ export class WaRetryCoordinator {
         if (!saved || !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,

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

@@ -1,8 +1,8 @@
 import { CsTokenGenerator } from '../tokens/cs-token.js';
-import { isTokenExpired, shouldSendNewToken, clampDuration } from '../tokens/tc-token.js';
+import { clampDuration, isTokenExpired, shouldSendNewToken } from '../tokens/tc-token.js';
 import { PromiseDedup } from '../../infra/perf/PromiseDedup.js';
 import { WA_PRIVACY_TOKEN_TYPES, WA_TC_TOKEN_DEFAULTS } from '../../protocol/privacy-token.js';
-import { buildPrivacyTokenIqNode, buildTcTokenMessageNode, buildCsTokenMessageNode } from '../../transport/node/builders/privacy-token.js';
+import { buildCsTokenMessageNode, buildPrivacyTokenIqNode, buildTcTokenMessageNode } from '../../transport/node/builders/privacy-token.js';
 import { toError } from '../../util/primitives.js';
 const NCT_SALT_SENTINEL_JID = '__nct_salt__';
 export class WaTrustedContactTokenCoordinator {
@@ -11,24 +11,40 @@ export class WaTrustedContactTokenCoordinator {
         this.store = options.store;
         this.runtime = options.runtime;
         const maxDurationS = options.maxDurationS ?? WA_TC_TOKEN_DEFAULTS.MAX_DURATION_S;
-        this.config = {
+        this.baseConfig = {
             durationS: clampDuration(options.durationS ?? WA_TC_TOKEN_DEFAULTS.DURATION_S, maxDurationS),
             numBuckets: options.numBuckets ?? WA_TC_TOKEN_DEFAULTS.NUM_BUCKETS,
             senderDurationS: clampDuration(options.senderDurationS ?? WA_TC_TOKEN_DEFAULTS.SENDER_DURATION_S, maxDurationS),
             senderNumBuckets: options.senderNumBuckets ?? WA_TC_TOKEN_DEFAULTS.SENDER_NUM_BUCKETS,
             maxDurationS
         };
+        this.getConfigOverrides = options.getConfigOverrides;
         this.csTokenGenerator = new CsTokenGenerator();
         this.senderTokenDedup = new PromiseDedup();
         this.cachedNctSalt = null;
         this.nctSaltHydrated = false;
     }
+    resolveConfig() {
+        const overrides = this.getConfigOverrides?.();
+        if (!overrides) {
+            return this.baseConfig;
+        }
+        const maxDurationS = overrides.maxDurationS ?? this.baseConfig.maxDurationS;
+        return {
+            durationS: clampDuration(overrides.durationS ?? this.baseConfig.durationS, maxDurationS),
+            numBuckets: overrides.numBuckets ?? this.baseConfig.numBuckets,
+            senderDurationS: clampDuration(overrides.senderDurationS ?? this.baseConfig.senderDurationS, maxDurationS),
+            senderNumBuckets: overrides.senderNumBuckets ?? this.baseConfig.senderNumBuckets,
+            maxDurationS
+        };
+    }
     async resolveTokenForMessage(recipientJid) {
         const record = await this.store.getByJid(recipientJid);
         const nowS = Math.floor(Date.now() / 1000);
+        const config = this.resolveConfig();
         if (record?.tcToken &&
             record.tcTokenTimestamp !== undefined &&
-            !isTokenExpired(record.tcTokenTimestamp, nowS, this.config.durationS, this.config.numBuckets)) {
+            !isTokenExpired(record.tcTokenTimestamp, nowS, config.durationS, config.numBuckets)) {
             return buildTcTokenMessageNode(record.tcToken);
         }
         const nctSalt = await this.getNctSalt();
@@ -69,8 +85,9 @@ export class WaTrustedContactTokenCoordinator {
             const nowS = Math.floor(Date.now() / 1000);
             const record = await this.store.getByJid(recipientJid);
             const senderTimestampS = record?.tcTokenSenderTimestamp;
+            const config = this.resolveConfig();
             if (senderTimestampS !== undefined && senderTimestampS > 0) {
-                if (!shouldSendNewToken(senderTimestampS, nowS, this.config.senderDurationS)) {
+                if (!shouldSendNewToken(senderTimestampS, nowS, config.senderDurationS)) {
                     return;
                 }
             }
@@ -88,7 +105,8 @@ export class WaTrustedContactTokenCoordinator {
             return;
         }
         const nowS = Math.floor(Date.now() / 1000);
-        if (isTokenExpired(record.tcTokenSenderTimestamp, nowS, this.config.senderDurationS, this.config.senderNumBuckets)) {
+        const config = this.resolveConfig();
+        if (isTokenExpired(record.tcTokenSenderTimestamp, nowS, config.senderDurationS, config.senderNumBuckets)) {
             return;
         }
         try {

package/dist/esm/client/dirty.js

@@ -262,7 +262,7 @@ async function clearDirtyBits(runtime, dirtyBits) {
     try {
         await runtime.queryWithContext('dirty.clear', buildClearDirtyBitsIq(dirtyBits), WA_DEFAULTS.IQ_TIMEOUT_MS, {
             count: dirtyBits.length
-        });
+        }, { useSystemId: true });
         runtime.logger.info('dirty bits cleared', {
             count: dirtyBits.length
         });

package/dist/esm/client/events/abprops.js

@@ -0,0 +1,40 @@
+import { findNodeChild, getNodeChildren } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
+export function parseAbPropsIqResult(node) {
+    const propsNode = findNodeChild(node, 'props');
+    if (!propsNode) {
+        return {
+            abKey: null,
+            hash: null,
+            refresh: null,
+            refreshId: null,
+            isDeltaUpdate: false,
+            props: []
+        };
+    }
+    const attrs = propsNode.attrs;
+    const propChildren = getNodeChildren(propsNode);
+    const props = [];
+    for (let i = 0; i < propChildren.length; i += 1) {
+        const child = propChildren[i];
+        if (child.tag !== 'prop') {
+            continue;
+        }
+        const configCode = parseOptionalInt(child.attrs.config_code);
+        if (configCode === undefined) {
+            continue;
+        }
+        props.push({
+            configCode,
+            configValue: child.attrs.config_value ?? null
+        });
+    }
+    return {
+        abKey: attrs.ab_key ?? null,
+        hash: attrs.hash ?? null,
+        refresh: parseOptionalInt(attrs.refresh) ?? null,
+        refreshId: parseOptionalInt(attrs.refresh_id) ?? null,
+        isDeltaUpdate: attrs.delta_update === 'true',
+        props
+    };
+}

package/dist/esm/client/events/privacy-token.js

@@ -1,6 +1,5 @@
 import { WA_PRIVACY_TOKEN_TAGS } from '../../protocol/privacy-token.js';
 import { findNodeChild, getNodeChildren } from '../../transport/node/helpers.js';
-import { toBytesView } from '../../util/bytes.js';
 import { asNumber } from '../../util/coercion.js';
 export function parsePrivacyTokenNotification(node) {
     const tokensNode = findNodeChild(node, WA_PRIVACY_TOKEN_TAGS.TOKENS);
@@ -28,7 +27,7 @@ export function parsePrivacyTokenNotification(node) {
         }
         result[result.length] = {
             type,
-            tokenBytes: toBytesView(content),
+            tokenBytes: content,
             timestampS: asNumber(Number(rawTimestamp), 'privacy_token.t')
         };
     }

package/dist/esm/client/events/registration.js

@@ -0,0 +1,39 @@
+import { WA_REGISTRATION_NOTIFICATION_TAGS } from '../../protocol/notification.js';
+import { getFirstNodeChild } from '../../transport/node/helpers.js';
+import { parseOptionalInt } from '../../util/primitives.js';
+export function parseRegistrationNotification(node) {
+    const firstChild = getFirstNodeChild(node);
+    if (!firstChild) {
+        return null;
+    }
+    if (firstChild.tag === WA_REGISTRATION_NOTIFICATION_TAGS.WA_OLD_REGISTRATION) {
+        const code = firstChild.attrs.code;
+        const expirySeconds = parseOptionalInt(firstChild.attrs.expiry_t);
+        const fromDeviceId = firstChild.attrs.device_id;
+        if (!code || expirySeconds === undefined || !fromDeviceId) {
+            return null;
+        }
+        return {
+            kind: 'registration_code',
+            code,
+            expiryTimestampMs: expirySeconds * 1000,
+            fromDeviceId
+        };
+    }
+    if (firstChild.tag === WA_REGISTRATION_NOTIFICATION_TAGS.DEVICE_LOGOUT) {
+        const serverToken = firstChild.attrs.id;
+        const tSeconds = parseOptionalInt(firstChild.attrs.t);
+        if (!serverToken || tSeconds === undefined) {
+            return null;
+        }
+        return {
+            kind: 'account_takeover_notice',
+            serverToken,
+            attemptTimestampMs: tSeconds * 1000,
+            newDeviceName: firstChild.attrs.device,
+            newDevicePlatform: firstChild.attrs.new_device_platform,
+            newDeviceAppVersion: firstChild.attrs.new_device_app_version
+        };
+    }
+    return null;
+}

package/dist/esm/client/incoming.js

@@ -1,4 +1,5 @@
 import { parseGroupNotificationEvents } from './events/group.js';
+import { parseRegistrationNotification } from './events/registration.js';
 import { WA_DISCONNECT_REASONS, WA_NODE_TAGS, WA_NOTIFICATION_TYPES } from '../protocol/constants.js';
 import { buildAckNode } from '../transport/node/builders/global.js';
 import { getFirstNodeChild, getNodeChildrenNonEmptyAttrValuesByTag } from '../transport/node/helpers.js';
@@ -217,6 +218,41 @@ export function createIncomingNotificationHandler(options) {
         return true;
     };
 }
+export function createIncomingRegistrationNotificationHandler(options) {
+    return async (node) => {
+        if (node.attrs.type !== WA_NOTIFICATION_TYPES.REGISTRATION) {
+            return false;
+        }
+        const parsed = parseRegistrationNotification(node);
+        if (!parsed) {
+            return false;
+        }
+        const baseEvent = createIncomingBaseEvent(node);
+        if (parsed.kind === 'registration_code') {
+            options.emitRegistrationCode({
+                ...baseEvent,
+                code: parsed.code,
+                expiryTimestampMs: parsed.expiryTimestampMs,
+                fromDeviceId: parsed.fromDeviceId
+            });
+        }
+        else {
+            options.emitAccountTakeoverNotice({
+                ...baseEvent,
+                serverToken: parsed.serverToken,
+                attemptTimestampMs: parsed.attemptTimestampMs,
+                newDeviceName: parsed.newDeviceName,
+                newDevicePlatform: parsed.newDevicePlatform,
+                newDeviceAppVersion: parsed.newDeviceAppVersion
+            });
+        }
+        await sendSafeAck(options.logger, options.sendNode, buildAckNode({
+            kind: 'notification',
+            node
+        }));
+        return true;
+    };
+}
 export function createIncomingGroupNotificationHandler(options) {
     return async (node) => {
         if (node.attrs.type !== WA_NOTIFICATION_TYPES.GROUP) {

package/dist/esm/client/mailbox.js

@@ -1,3 +1,4 @@
+import { needsSecretPersistence } from '../message/content.js';
 import { proto } from '../proto.js';
 import { toError } from '../util/primitives.js';
 function persistContacts(writeBehind, event, nowMs) {
@@ -14,7 +15,7 @@ function persistContacts(writeBehind, event, nowMs) {
     }
 }
 export function persistIncomingMailboxEntities(options) {
-    const { logger, writeBehind, event } = options;
+    const { logger, writeBehind, messageSecretStore, event } = options;
     const { stanzaId, chatJid } = event;
     if (!stanzaId || !chatJid) {
         return;
@@ -36,6 +37,21 @@ export function persistIncomingMailboxEntities(options) {
             messageBytes
         });
         persistContacts(writeBehind, event, nowMs);
+        const rawSecret = event.message?.messageContextInfo?.messageSecret;
+        if (rawSecret &&
+            rawSecret.length > 0 &&
+            event.message &&
+            needsSecretPersistence(event.message)) {
+            const senderJid = event.senderJid ?? event.rawNode.attrs.participant ?? '';
+            void messageSecretStore
+                .set(stanzaId, { secret: rawSecret, senderJid })
+                .catch((error) => {
+                logger.warn('failed to persist message secret', {
+                    id: stanzaId,
+                    message: toError(error).message
+                });
+            });
+        }
     }
     catch (error) {
         logger.warn('failed to persist incoming mailbox entities', {