zapo-js 0.2.0 → 1.0.0

package/dist/esm/client/{history-sync.js → persistence/history-sync.js}

@@ -1,20 +1,44 @@
 import { promisify } from 'node:util';
 import { unzip } from 'node:zlib';
-import { proto } from '../proto.js';
-import { decodeProtoBytes, toBytesView } from '../util/bytes.js';
-import { longToNumber } from '../util/primitives.js';
+import { proto } from '../../proto.js';
+import { isUserJid } from '../../protocol/jid.js';
+import { decodeProtoBytes, toBytesView } from '../../util/bytes.js';
+import { longToNumber, toError } from '../../util/primitives.js';
 const unzipAsync = promisify(unzip);
 const HANDLED_SYNC_TYPES = new Set([
     proto.Message.HistorySyncType.INITIAL_BOOTSTRAP,
     proto.Message.HistorySyncType.RECENT,
     proto.Message.HistorySyncType.FULL,
-    proto.Message.HistorySyncType.PUSH_NAME
+    proto.Message.HistorySyncType.PUSH_NAME,
+    proto.Message.HistorySyncType.ON_DEMAND,
+    proto.Message.HistorySyncType.NON_BLOCKING_DATA
 ]);
 const HISTORY_SYNC_MAX_PENDING_WRITES = 1024;
+export async function runHistorySyncNotification(deps, notification) {
+    try {
+        await processHistorySyncNotification(deps, notification);
+    }
+    catch (error) {
+        deps.logger.warn('failed to process history sync notification', {
+            syncType: notification.syncType,
+            chunkOrder: notification.chunkOrder,
+            message: toError(error).message
+        });
+    }
+}
 export async function processHistorySyncNotification(deps, notification) {
     const syncType = notification.syncType;
-    if (syncType === null || syncType === undefined || !HANDLED_SYNC_TYPES.has(syncType)) {
+    if (syncType === null || syncType === undefined) {
+        deps.logger.debug('skipping history sync notification without syncType');
+        return;
+    }
+    if (!HANDLED_SYNC_TYPES.has(syncType)) {
         deps.logger.debug('skipping unhandled history sync type', { syncType });
+        // INITIAL_STATUS_V3 is the only recognized syncType we do not process today;
+        // still ack it so the primary device does not keep resending the same chunk.
+        if (syncType === proto.Message.HistorySyncType.INITIAL_STATUS_V3 && deps.onProcessed) {
+            await deps.onProcessed(syncType);
+        }
         return;
     }
     const blob = await downloadHistorySyncBlob(deps, notification);
@@ -25,17 +49,67 @@ export async function processHistorySyncNotification(deps, notification) {
         chunkOrder: historySync.chunkOrder,
         progress: historySync.progress,
         conversations: historySync.conversations.length,
-        pushnames: historySync.pushnames.length
+        pushnames: historySync.pushnames.length,
+        inlineContacts: historySync.inlineContacts?.length ?? 0
     });
     const nowMs = Date.now();
     const pendingWrites = [];
+    // Build PN -> LID lookup from this chunk's mappings (and inline contacts
+    // and conversation-level pn/lid pairs, which carry the same pair) so
+    // pushnames and mappings land on a single canonical (LID-form) contact
+    // row instead of two mirror rows (one keyed by PN, one keyed by LID).
+    const pnToLid = new Map();
+    for (const map of historySync.phoneNumberToLidMappings ?? []) {
+        if (map.pnJid && map.lidJid) {
+            pnToLid.set(map.pnJid, map.lidJid);
+        }
+    }
+    for (const c of historySync.inlineContacts ?? []) {
+        if (c.pnJid && c.lidJid) {
+            pnToLid.set(c.pnJid, c.lidJid);
+        }
+    }
+    for (const conversation of historySync.conversations) {
+        const pnJid = conversation.pnJid;
+        const lidJid = conversation.lidJid ?? conversation.accountLid;
+        if (pnJid && lidJid) {
+            pnToLid.set(pnJid, lidJid);
+        }
+    }
     for (const pn of historySync.pushnames) {
         if (!pn.id) {
             continue;
         }
+        const lidJid = pnToLid.get(pn.id);
+        pendingWrites[pendingWrites.length] = deps.writeBehind.persistContactAsync(lidJid
+            ? {
+                jid: lidJid,
+                pushName: pn.pushname ?? undefined,
+                phoneNumber: pn.id,
+                lastUpdatedMs: nowMs
+            }
+            : {
+                jid: pn.id,
+                pushName: pn.pushname ?? undefined,
+                lastUpdatedMs: nowMs
+            });
+        if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
+            await flushPendingWrites(pendingWrites);
+        }
+    }
+    for (const c of historySync.inlineContacts ?? []) {
+        const jid = c.lidJid ?? c.pnJid;
+        if (!jid) {
+            continue;
+        }
+        const displayName = c.fullName || c.firstName || undefined;
+        if (!displayName && !c.pnJid) {
+            continue;
+        }
         pendingWrites[pendingWrites.length] = deps.writeBehind.persistContactAsync({
-            jid: pn.id,
-            pushName: pn.pushname ?? undefined,
+            jid,
+            displayName,
+            phoneNumber: c.pnJid ?? undefined,
             lastUpdatedMs: nowMs
         });
         if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
@@ -62,9 +136,30 @@ export async function processHistorySyncNotification(deps, notification) {
         if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
             await flushPendingWrites(pendingWrites);
         }
+        if (isUserJid(threadJid) || (conversation.lidJid ?? conversation.accountLid)) {
+            const contactDisplay = conversation.displayName || conversation.username || undefined;
+            const contactPn = conversation.pnJid ?? undefined;
+            const contactLid = conversation.lidJid ?? conversation.accountLid ?? undefined;
+            if (contactDisplay || contactPn || contactLid) {
+                const contactJid = contactLid ?? threadJid;
+                pendingWrites[pendingWrites.length] = deps.writeBehind.persistContactAsync({
+                    jid: contactJid,
+                    displayName: contactDisplay,
+                    phoneNumber: contactPn,
+                    lastUpdatedMs: nowMs
+                });
+                if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
+                    await flushPendingWrites(pendingWrites);
+                }
+            }
+        }
         for (const histMsg of conversation.messages ?? []) {
             const webMsg = histMsg.message;
-            if (!webMsg?.key?.id) {
+            if (!webMsg?.key?.id || !webMsg.message) {
+                // Stubs (group system events: add/remove/promote, revokes, ephemeral toggles)
+                // arrive as WebMessageInfo with a key + messageStubType but no `.message`. They
+                // duplicate live `notification` stanzas that the client already processes, and
+                // storing them as content-less rows produces "ghost" entries — skip them here.
                 continue;
             }
             const timestampMs = longToNumber(webMsg.messageTimestamp) * 1000;
@@ -74,9 +169,7 @@ export async function processHistorySyncNotification(deps, notification) {
                 senderJid: webMsg.key.participant ?? undefined,
                 fromMe: webMsg.key.fromMe === true,
                 timestampMs: timestampMs || undefined,
-                messageBytes: webMsg.message
-                    ? proto.Message.encode(webMsg.message).finish()
-                    : undefined
+                messageBytes: proto.Message.encode(webMsg.message).finish()
             });
             if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
                 await flushPendingWrites(pendingWrites);
@@ -84,6 +177,19 @@ export async function processHistorySyncNotification(deps, notification) {
             messagesCount += 1;
         }
     }
+    // Persist LID<->PN mappings as a single LID-canonical row per contact.
+    // Lookups by PN form fall through to `getByPhoneNumber` via the secondary
+    // index, so the mirror PN row is no longer needed.
+    for (const [pnJid, lidJid] of pnToLid) {
+        pendingWrites[pendingWrites.length] = deps.writeBehind.persistContactAsync({
+            jid: lidJid,
+            phoneNumber: pnJid,
+            lastUpdatedMs: nowMs
+        });
+        if (pendingWrites.length >= HISTORY_SYNC_MAX_PENDING_WRITES) {
+            await flushPendingWrites(pendingWrites);
+        }
+    }
     if (deps.onPrivacyTokens) {
         const tokenConversations = [];
         for (const conversation of historySync.conversations) {
@@ -112,23 +218,23 @@ export async function processHistorySyncNotification(deps, notification) {
         messagesCount,
         conversationsCount: historySync.conversations.length,
         pushnamesCount: historySync.pushnames.length,
+        inlineContactsCount: historySync.inlineContacts?.length ?? 0,
         chunkOrder: historySync.chunkOrder ?? undefined,
         progress: historySync.progress ?? undefined
     };
     await flushPendingWrites(pendingWrites);
     deps.emitEvent('history_sync_chunk', event);
+    if (deps.onProcessed) {
+        await deps.onProcessed(syncType);
+    }
 }
 async function flushPendingWrites(pendingWrites) {
     if (pendingWrites.length === 0) {
         return;
     }
-    const pendingCount = pendingWrites.length;
-    const batch = new Array(pendingCount);
-    for (let index = 0; index < pendingCount; index += 1) {
-        batch[index] = pendingWrites[index];
-    }
+    const settled = Promise.all(pendingWrites);
     pendingWrites.length = 0;
-    await Promise.all(batch);
+    await settled;
 }
 async function downloadHistorySyncBlob(deps, notification) {
     if (notification.initialHistBootstrapInlinePayload) {

package/dist/esm/client/persistence/mailbox.js

@@ -0,0 +1,101 @@
+import { needsSecretPersistence } from '../../message/encode/content.js';
+import { proto } from '../../proto.js';
+import { isLidJid, isUserJid, toUserJid } from '../../protocol/jid.js';
+import { toError } from '../../util/primitives.js';
+function pairLidPn(a, b) {
+    if (!a || !b)
+        return null;
+    if (isLidJid(a) && isUserJid(b))
+        return [a, b];
+    if (isLidJid(b) && isUserJid(a))
+        return [b, a];
+    return null;
+}
+/**
+ * Returns the LID-canonical contact record for a primary jid and (optionally)
+ * its alternate addressing. When both forms are known, the row carries
+ * `jid=<lid>, phoneNumber=<pn>` so lookups by either form converge on a
+ * single row via the contact store's PN-fallback path. When only one form is
+ * known, the row falls back to that jid as canonical.
+ */
+function canonicalContact(primary, alt, nowMs) {
+    const pair = pairLidPn(primary, alt);
+    if (pair) {
+        const [lid, pn] = pair;
+        return { jid: lid, phoneNumber: pn, lastUpdatedMs: nowMs };
+    }
+    return { jid: primary, lastUpdatedMs: nowMs };
+}
+function persistContacts(writeBehind, event, nowMs) {
+    const rawParticipant = event.rawNode.attrs.participant;
+    const participantJid = rawParticipant ? toUserJid(rawParticipant) : undefined;
+    const senderPrimary = event.key.participant ?? rawParticipant ?? event.key.remoteJid;
+    if (!senderPrimary && !participantJid) {
+        return;
+    }
+    const written = new Set();
+    if (senderPrimary) {
+        // For 1:1 chats the sender is the same person as remoteJid, so its
+        // cross-ref pair info lives in remoteJidAlt rather than participantAlt.
+        let alt = event.key.participantAlt;
+        if (!alt && !event.key.isGroup && senderPrimary === event.key.remoteJid) {
+            alt = event.key.remoteJidAlt;
+        }
+        const record = canonicalContact(senderPrimary, alt, nowMs);
+        writeBehind.persistContact(record);
+        written.add(record.jid);
+        if (record.phoneNumber) {
+            written.add(record.phoneNumber);
+        }
+    }
+    if (participantJid && !written.has(participantJid)) {
+        writeBehind.persistContact({ jid: participantJid, lastUpdatedMs: nowMs });
+    }
+}
+export function persistIncomingMailboxEntities(options) {
+    const { logger, writeBehind, messageSecretStore, event } = options;
+    const stanzaId = event.key.id;
+    const chatJid = event.key.remoteJid;
+    if (!stanzaId || !chatJid) {
+        return;
+    }
+    const nowMs = Date.now();
+    try {
+        const messageBytes = event.message
+            ? proto.Message.encode(event.message).finish()
+            : undefined;
+        writeBehind.persistMessage({
+            id: stanzaId,
+            threadJid: chatJid,
+            senderJid: event.key.participant ?? event.rawNode.attrs.participant ?? event.key.remoteJid,
+            participantJid: event.rawNode.attrs.participant,
+            fromMe: false,
+            timestampMs: event.timestampSeconds === undefined ? undefined : event.timestampSeconds * 1000,
+            messageBytes
+        });
+        persistContacts(writeBehind, event, nowMs);
+        const rawSecret = event.message?.messageContextInfo?.messageSecret;
+        if (rawSecret &&
+            rawSecret.length > 0 &&
+            event.message &&
+            needsSecretPersistence(event.message)) {
+            const rawSender = event.key.participant ?? event.rawNode.attrs.participant ?? event.key.remoteJid;
+            const senderJid = rawSender ? toUserJid(rawSender) : '';
+            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', {
+            id: stanzaId,
+            from: chatJid,
+            message: toError(error).message
+        });
+    }
+}

package/dist/esm/client/tokens/cs-token.js

@@ -1,25 +1,28 @@
-import { hmacSign, importHmacKey } from '../../crypto/core/index.js';
+import { hmacSha256Sign } from '../../crypto/core/index.js';
 import { TEXT_ENCODER } from '../../util/bytes.js';
 import { setBoundedMapEntry } from '../../util/collections.js';
 const CS_TOKEN_CACHE_MAX = 5;
 export class CsTokenGenerator {
     constructor() {
-        this.cachedKey = null;
         this.cachedSalt = null;
         this.cache = new Map();
     }
-    async generate(nctSalt, accountLid) {
-        const cached = this.cache.get(accountLid);
-        if (cached && this.isSameSalt(nctSalt)) {
-            return cached;
+    generate(nctSalt, accountLid) {
+        if (this.isSameSalt(nctSalt)) {
+            const cached = this.cache.get(accountLid);
+            if (cached) {
+                return cached;
+            }
+        }
+        const result = hmacSha256Sign(nctSalt, TEXT_ENCODER.encode(accountLid));
+        if (!this.isSameSalt(nctSalt)) {
+            this.cachedSalt = nctSalt;
+            this.cache.clear();
         }
-        const key = await this.resolveKey(nctSalt);
-        const result = await hmacSign(key, TEXT_ENCODER.encode(accountLid));
         setBoundedMapEntry(this.cache, accountLid, result, CS_TOKEN_CACHE_MAX);
         return result;
     }
     invalidate() {
-        this.cachedKey = null;
         this.cachedSalt = null;
         this.cache.clear();
     }
@@ -34,13 +37,4 @@ export class CsTokenGenerator {
         }
         return true;
     }
-    async resolveKey(salt) {
-        if (this.cachedKey && this.isSameSalt(salt)) {
-            return this.cachedKey;
-        }
-        this.cachedKey = await importHmacKey(salt);
-        this.cachedSalt = salt;
-        this.cache.clear();
-        return this.cachedKey;
-    }
 }

package/dist/esm/crypto/core/hkdf.js

@@ -1,17 +1,17 @@
-import { webcrypto } from 'node:crypto';
-import { EMPTY_BYTES, TEXT_ENCODER, toBytesView } from '../../util/bytes.js';
-export async function hkdf(ikm, salt, info, outLength) {
-    const key = await webcrypto.subtle.importKey('raw', ikm, 'HKDF', false, ['deriveBits']);
-    const infoBytes = typeof info === 'string' ? (info === '' ? EMPTY_BYTES : TEXT_ENCODER.encode(info)) : info;
-    const bits = await webcrypto.subtle.deriveBits({
-        name: 'HKDF',
-        hash: 'SHA-256',
-        salt: salt ?? EMPTY_BYTES,
-        info: infoBytes
-    }, key, outLength * 8);
-    return toBytesView(bits);
+import { hkdfSync } from 'node:crypto';
+import { EMPTY_BYTES, toBytesView } from '../../util/bytes.js';
+/**
+ * HKDF (HMAC-SHA-256) – derives `outLength` bytes from `ikm` using the given
+ * `salt` (empty bytes when `null`) and `info` context.
+ */
+export function hkdf(ikm, salt, info, outLength) {
+    return toBytesView(hkdfSync('sha256', ikm, salt ?? EMPTY_BYTES, info, outLength));
 }
-export async function hkdfSplit(ikm, salt, info) {
-    const out = await hkdf(ikm, salt, info, 64);
+/**
+ * Derives a 64-byte HKDF output and returns it split into two 32-byte halves
+ * (Signal/WhatsApp pair-key derivation pattern).
+ */
+export function hkdfSplit(ikm, salt, info) {
+    const out = hkdf(ikm, salt, info, 64);
     return [out.subarray(0, 32), out.subarray(32)];
 }

package/dist/esm/crypto/core/index.js

@@ -5,6 +5,7 @@ export { Ed25519 } from '../curves/Ed25519.js';
 export { X25519 } from '../curves/X25519.js';
 export { hkdf, hkdfSplit } from '../core/hkdf.js';
 export { toSerializedPubKey, toRawPubKey, prependVersion, readVersionedContent } from '../core/keys.js';
-export { buildNonce } from '../core/nonce.js';
+export { writeNonceCounter } from '../core/nonce.js';
 export { randomBytesAsync, randomFillAsync, randomIntAsync } from '../core/random.js';
-export { sha1, sha256, sha512, importAesGcmKey, aesGcmEncrypt, aesGcmDecrypt, importAesCbcKey, aesCbcEncrypt, aesCbcDecrypt, importHmacKey, importHmacSha512Key, hmacSign, pbkdf2DeriveAesCtrKey, aesCtrEncrypt, aesCtrDecrypt } from '../core/primitives.js';
+export { sha1, sha256, sha512, md5Bytes, aesGcmEncrypt, aesGcmDecrypt, aesCbcEncrypt, aesCbcDecrypt, aesCtrEncrypt, aesCtrDecrypt, hmacSha256Sign, hmacSha512Sign, pbkdf2Sha256 } from '../core/primitives.js';
+export { xeddsaSign, xeddsaVerify } from '../core/xeddsa.js';

package/dist/esm/crypto/core/keys.js

@@ -28,18 +28,12 @@ export function toRawPubKey(key) {
     }
     throw new Error(`invalid signal public key length ${key.length}`);
 }
-/**
- * Creates a version byte from high and low nibbles
- */
-export function versionByte(high, low) {
-    return ((high << 4) | low) & 0xff;
-}
 /**
  * Prepends a version byte to content
  */
 export function prependVersion(content, version) {
     const out = new Uint8Array(1 + content.length);
-    out[0] = versionByte(version, version);
+    out[0] = ((version << 4) | version) & 0xff;
     out.set(content, 1);
     return out;
 }

package/dist/esm/crypto/core/nonce.js

@@ -1,17 +1,17 @@
 /**
- * Builds a 12-byte nonce for AES-GCM encryption with counter in the last 4 bytes.
- * Allocates a new buffer per call because concurrent Noise encrypt/decrypt operations
- * may hold references to different nonces simultaneously.
- * Throws if counter exceeds uint32 range to prevent nonce reuse.
+ * Writes a 32-bit big-endian `counter` into the last 4 bytes of a 12-byte
+ * AES-GCM nonce buffer. The first 8 bytes are left untouched so callers can
+ * reuse a per-instance scratch buffer in hot paths.
  */
-export function buildNonce(counter) {
+export function writeNonceCounter(out, counter) {
+    if (out.length < 12) {
+        throw new Error(`nonce buffer must be at least 12 bytes, got ${out.length}`);
+    }
     if (counter > 0xffffffff) {
         throw new Error('nonce counter overflow: exceeds uint32 range');
     }
-    const nonce = new Uint8Array(12);
-    nonce[8] = (counter >>> 24) & 0xff;
-    nonce[9] = (counter >>> 16) & 0xff;
-    nonce[10] = (counter >>> 8) & 0xff;
-    nonce[11] = counter & 0xff;
-    return nonce;
+    out[8] = (counter >>> 24) & 0xff;
+    out[9] = (counter >>> 16) & 0xff;
+    out[10] = (counter >>> 8) & 0xff;
+    out[11] = counter & 0xff;
 }