zapo-js 0.1.1 → 0.2.0

package/dist/client/coordinators/WaTrustedContactTokenCoordinator.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaTrustedContactTokenCoordinator = void 0;
+const cs_token_1 = require("../tokens/cs-token");
+const tc_token_1 = require("../tokens/tc-token");
+const PromiseDedup_1 = require("../../infra/perf/PromiseDedup");
+const privacy_token_1 = require("../../protocol/privacy-token");
+const privacy_token_2 = require("../../transport/node/builders/privacy-token");
+const primitives_1 = require("../../util/primitives");
+const NCT_SALT_SENTINEL_JID = '__nct_salt__';
+class WaTrustedContactTokenCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.store = options.store;
+        this.runtime = options.runtime;
+        const maxDurationS = options.maxDurationS ?? privacy_token_1.WA_TC_TOKEN_DEFAULTS.MAX_DURATION_S;
+        this.config = {
+            durationS: (0, tc_token_1.clampDuration)(options.durationS ?? privacy_token_1.WA_TC_TOKEN_DEFAULTS.DURATION_S, maxDurationS),
+            numBuckets: options.numBuckets ?? privacy_token_1.WA_TC_TOKEN_DEFAULTS.NUM_BUCKETS,
+            senderDurationS: (0, tc_token_1.clampDuration)(options.senderDurationS ?? privacy_token_1.WA_TC_TOKEN_DEFAULTS.SENDER_DURATION_S, maxDurationS),
+            senderNumBuckets: options.senderNumBuckets ?? privacy_token_1.WA_TC_TOKEN_DEFAULTS.SENDER_NUM_BUCKETS,
+            maxDurationS
+        };
+        this.csTokenGenerator = new cs_token_1.CsTokenGenerator();
+        this.senderTokenDedup = new PromiseDedup_1.PromiseDedup();
+        this.cachedNctSalt = null;
+        this.nctSaltHydrated = false;
+    }
+    async resolveTokenForMessage(recipientJid) {
+        const record = await this.store.getByJid(recipientJid);
+        const nowS = Math.floor(Date.now() / 1000);
+        if (record?.tcToken &&
+            record.tcTokenTimestamp !== undefined &&
+            !(0, tc_token_1.isTokenExpired)(record.tcTokenTimestamp, nowS, this.config.durationS, this.config.numBuckets)) {
+            return (0, privacy_token_2.buildTcTokenMessageNode)(record.tcToken);
+        }
+        const nctSalt = await this.getNctSalt();
+        if (!nctSalt) {
+            return null;
+        }
+        const meLid = this.runtime.getCurrentMeLid();
+        if (!meLid) {
+            return null;
+        }
+        const hash = await this.csTokenGenerator.generate(nctSalt, meLid);
+        return (0, privacy_token_2.buildCsTokenMessageNode)(hash);
+    }
+    async handleIncomingToken(fromJid, tokens) {
+        const nowMs = Date.now();
+        for (let i = 0; i < tokens.length; i += 1) {
+            const token = tokens[i];
+            if (token.type !== privacy_token_1.WA_PRIVACY_TOKEN_TYPES.TRUSTED_CONTACT) {
+                this.logger.warn('ignoring unknown privacy token type', { type: token.type });
+                continue;
+            }
+            await this.store.upsert({
+                jid: fromJid,
+                tcToken: token.tokenBytes,
+                tcTokenTimestamp: token.timestampS,
+                updatedAtMs: nowMs
+            });
+            this.runtime.emitEvent('privacy_token_update', {
+                jid: fromJid,
+                timestampS: token.timestampS,
+                type: token.type,
+                source: 'notification'
+            });
+        }
+    }
+    async maybeIssueSenderToken(recipientJid) {
+        return this.senderTokenDedup.run(recipientJid, async () => {
+            const nowS = Math.floor(Date.now() / 1000);
+            const record = await this.store.getByJid(recipientJid);
+            const senderTimestampS = record?.tcTokenSenderTimestamp;
+            if (senderTimestampS !== undefined && senderTimestampS > 0) {
+                if (!(0, tc_token_1.shouldSendNewToken)(senderTimestampS, nowS, this.config.senderDurationS)) {
+                    return;
+                }
+            }
+            await this.issuePrivacyToken(recipientJid, nowS);
+            await this.store.upsert({
+                jid: recipientJid,
+                tcTokenSenderTimestamp: nowS,
+                updatedAtMs: Date.now()
+            });
+        });
+    }
+    async reissueOnIdentityChange(jid) {
+        const record = await this.store.getByJid(jid);
+        if (!record?.tcTokenSenderTimestamp) {
+            return;
+        }
+        const nowS = Math.floor(Date.now() / 1000);
+        if ((0, tc_token_1.isTokenExpired)(record.tcTokenSenderTimestamp, nowS, this.config.senderDurationS, this.config.senderNumBuckets)) {
+            return;
+        }
+        try {
+            await this.issuePrivacyToken(jid, record.tcTokenSenderTimestamp);
+        }
+        catch (error) {
+            this.logger.warn('send-tc-token-device-identity-change-failed', {
+                jid,
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
+    }
+    async hydrateFromHistorySync(conversations) {
+        const nowMs = Date.now();
+        const records = [];
+        for (let i = 0; i < conversations.length; i += 1) {
+            const conv = conversations[i];
+            if (!conv.tcToken && !conv.tcTokenTimestamp && !conv.tcTokenSenderTimestamp) {
+                continue;
+            }
+            records[records.length] = {
+                jid: conv.jid,
+                tcToken: conv.tcToken ?? undefined,
+                tcTokenTimestamp: conv.tcTokenTimestamp ?? undefined,
+                tcTokenSenderTimestamp: conv.tcTokenSenderTimestamp ?? undefined,
+                updatedAtMs: nowMs
+            };
+        }
+        if (records.length > 0) {
+            await this.store.upsertBatch(records);
+        }
+    }
+    async handleNctSaltSync(salt) {
+        if (salt) {
+            await this.store.upsert({
+                jid: NCT_SALT_SENTINEL_JID,
+                nctSalt: salt,
+                updatedAtMs: Date.now()
+            });
+            this.cachedNctSalt = salt;
+        }
+        else {
+            await this.store.deleteByJid(NCT_SALT_SENTINEL_JID);
+            this.cachedNctSalt = null;
+        }
+        this.nctSaltHydrated = true;
+        this.csTokenGenerator.invalidate();
+    }
+    async hydrateNctSaltFromHistorySync(salt) {
+        await this.store.upsert({
+            jid: NCT_SALT_SENTINEL_JID,
+            nctSalt: salt,
+            updatedAtMs: Date.now()
+        });
+        this.cachedNctSalt = salt;
+        this.nctSaltHydrated = true;
+    }
+    async getNctSalt() {
+        if (this.nctSaltHydrated) {
+            return this.cachedNctSalt;
+        }
+        const record = await this.store.getByJid(NCT_SALT_SENTINEL_JID);
+        this.cachedNctSalt = record?.nctSalt ?? null;
+        this.nctSaltHydrated = true;
+        return this.cachedNctSalt;
+    }
+    async issuePrivacyToken(jid, timestampS) {
+        const node = (0, privacy_token_2.buildPrivacyTokenIqNode)({ jid, timestampS });
+        await this.runtime.queryWithContext('issue-privacy-token', node);
+    }
+}
+exports.WaTrustedContactTokenCoordinator = WaTrustedContactTokenCoordinator;

package/dist/client/dirty.js

@@ -2,13 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDirtyBits = parseDirtyBits;
 exports.handleDirtyBits = handleDirtyBits;
-const _crypto_1 = require("../crypto/index.js");
 const constants_1 = require("../protocol/constants");
 const jid_1 = require("../protocol/jid");
-const accountSync_1 = require("../transport/node/builders/accountSync");
+const account_sync_1 = require("../transport/node/builders/account-sync");
 const helpers_1 = require("../transport/node/helpers");
 const query_1 = require("../transport/node/query");
-const bytes_1 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 const SUPPORTED_DIRTY_TYPES = new Set(constants_1.WA_SUPPORTED_DIRTY_TYPES);
 const ACCOUNT_SYNC_PROTOCOL_SET = new Set(constants_1.WA_ACCOUNT_SYNC_PROTOCOLS);
@@ -22,30 +20,36 @@ function parseDirtyBitNode(node, logger) {
         });
         return null;
     }
-    const protocols = (0, helpers_1.getNodeChildren)(node).map((child) => child.tag);
+    const protocols = (0, helpers_1.getNodeChildrenTags)(node);
     return {
         type,
         timestamp,
         protocols
     };
 }
-function splitDirtyBitsBySupport(dirtyBits) {
-    return {
-        supported: dirtyBits.filter((dirtyBit) => SUPPORTED_DIRTY_TYPES.has(dirtyBit.type)),
-        unsupported: dirtyBits.filter((dirtyBit) => !SUPPORTED_DIRTY_TYPES.has(dirtyBit.type))
-    };
-}
 function resolveAccountSyncProtocols(protocols) {
-    const selected = protocols.filter((protocol) => ACCOUNT_SYNC_PROTOCOL_SET.has(protocol));
+    const selected = [];
+    for (let index = 0; index < protocols.length; index += 1) {
+        const protocol = protocols[index];
+        if (ACCOUNT_SYNC_PROTOCOL_SET.has(protocol)) {
+            selected.push(protocol);
+        }
+    }
     if (selected.length > 0) {
         return selected;
     }
     return constants_1.WA_ACCOUNT_SYNC_PROTOCOLS;
 }
 function parseDirtyBits(nodes, logger) {
-    return nodes
-        .map((node) => parseDirtyBitNode(node, logger))
-        .filter((dirtyBit) => dirtyBit !== null);
+    const parsed = [];
+    for (const node of nodes) {
+        const dirtyBit = parseDirtyBitNode(node, logger);
+        if (!dirtyBit) {
+            continue;
+        }
+        parsed.push(dirtyBit);
+    }
+    return parsed;
 }
 async function handleDirtyBits(runtime, dirtyBits) {
     const meJid = runtime.getCurrentCredentials()?.meJid ?? null;
@@ -53,22 +57,45 @@ async function handleDirtyBits(runtime, dirtyBits) {
         runtime.logger.trace('dirty bits skipped: session is not registered');
         return;
     }
-    const { supported, unsupported } = splitDirtyBitsBySupport(dirtyBits);
+    const supported = [];
+    const unsupported = [];
+    for (const dirtyBit of dirtyBits) {
+        if (SUPPORTED_DIRTY_TYPES.has(dirtyBit.type)) {
+            supported.push(dirtyBit);
+            continue;
+        }
+        unsupported.push(dirtyBit);
+    }
+    const supportedTypes = new Array(supported.length);
+    for (let index = 0; index < supported.length; index += 1) {
+        supportedTypes[index] = supported[index].type;
+    }
+    const unsupportedTypes = new Array(unsupported.length);
+    for (let index = 0; index < unsupported.length; index += 1) {
+        unsupportedTypes[index] = unsupported[index].type;
+    }
     runtime.logger.info('handling dirty bits from info bulletin', {
-        supported: supported.map((entry) => entry.type).join(','),
-        unsupported: unsupported.map((entry) => entry.type).join(',')
+        supported: supportedTypes.join(','),
+        unsupported: unsupportedTypes.join(',')
     });
-    const handledSupported = (await Promise.allSettled(supported.map(async (dirtyBit) => handleDirtyBit(runtime, dirtyBit)))).flatMap((result, index) => {
+    const clearableDirtyBits = [...unsupported];
+    const supportedPromises = new Array(supported.length);
+    for (let index = 0; index < supported.length; index += 1) {
+        supportedPromises[index] = handleDirtyBit(runtime, supported[index]);
+    }
+    const settledSupported = await Promise.allSettled(supportedPromises);
+    for (let index = 0; index < settledSupported.length; index += 1) {
+        const result = settledSupported[index];
         if (result.status === 'fulfilled') {
-            return [supported[index]];
+            clearableDirtyBits.push(supported[index]);
+            continue;
         }
         runtime.logger.warn('failed handling dirty bit', {
             type: supported[index].type,
             message: (0, primitives_1.toError)(result.reason).message
         });
-        return [];
-    });
-    await clearDirtyBits(runtime, unsupported.concat(handledSupported));
+    }
+    await clearDirtyBits(runtime, clearableDirtyBits);
 }
 async function handleDirtyBit(runtime, dirtyBit) {
     switch (dirtyBit.type) {
@@ -96,18 +123,23 @@ async function handleAccountSyncDirtyBit(runtime, protocols) {
         protocols: selectedProtocols.join(',')
     });
     const failures = [];
-    await Promise.all(selectedProtocols.map(async (protocol) => {
-        try {
-            await runAccountSyncProtocol(runtime, protocol);
-        }
-        catch (error) {
-            failures.push(protocol);
-            runtime.logger.warn('account_sync protocol failed', {
-                protocol,
-                message: (0, primitives_1.toError)(error).message
-            });
-        }
-    }));
+    const protocolPromises = new Array(selectedProtocols.length);
+    for (let index = 0; index < selectedProtocols.length; index += 1) {
+        const protocol = selectedProtocols[index];
+        protocolPromises[index] = (async () => {
+            try {
+                await runAccountSyncProtocol(runtime, protocol);
+            }
+            catch (error) {
+                failures.push(protocol);
+                runtime.logger.warn('account_sync protocol failed', {
+                    protocol,
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        })();
+    }
+    await Promise.all(protocolPromises);
     if (failures.length > 0) {
         throw new Error(`account_sync protocols failed: ${failures.join(',')}`);
     }
@@ -127,7 +159,7 @@ async function runAccountSyncProtocol(runtime, protocol) {
             await syncAccountBlocklistDirtyBit(runtime);
             return;
         case constants_1.WA_DIRTY_PROTOCOLS.NOTICE:
-            await syncAccountNoticeDirtyBit(runtime);
+            runtime.logger.info('account_sync notice protocol received (no GraphQL/MEX job configured)');
             return;
         default:
             runtime.logger.debug('unsupported account_sync protocol', {
@@ -153,7 +185,7 @@ async function syncAccountDevicesDirtyBit(runtime) {
     }
     await runSyncQuery(runtime, {
         queryContext: 'account_sync.devices',
-        node: (0, accountSync_1.buildAccountDevicesSyncIq)(userJids, await generateUsyncSid()),
+        node: (0, account_sync_1.buildAccountDevicesSyncIq)(userJids, await runtime.generateUsyncSid()),
         logMessage: 'account_sync devices synchronized',
         contextData: { meJid, targets: userJids.join(',') }
     });
@@ -165,7 +197,7 @@ async function syncAccountPictureDirtyBit(runtime) {
         return;
     }
     const targetJid = (0, jid_1.toUserJid)(meJid);
-    const response = await runtime.queryWithContext('account_sync.picture', (0, accountSync_1.buildAccountPictureSyncIq)(targetJid), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, { meJid, target: targetJid });
+    const response = await runtime.queryWithContext('account_sync.picture', (0, account_sync_1.buildAccountPictureSyncIq)(targetJid), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, { meJid, target: targetJid });
     if (response.tag !== 'iq') {
         throw new Error(`account_sync.picture returned non-iq node (${response.tag})`);
     }
@@ -191,34 +223,28 @@ async function syncAccountPictureDirtyBit(runtime) {
 async function syncAccountPrivacyDirtyBit(runtime) {
     await runSyncQuery(runtime, {
         queryContext: 'account_sync.privacy',
-        node: (0, accountSync_1.buildAccountPrivacySyncIq)(),
+        node: (0, account_sync_1.buildAccountPrivacySyncIq)(),
         logMessage: 'account_sync privacy synchronized'
     });
 }
 async function syncAccountBlocklistDirtyBit(runtime) {
     await runSyncQuery(runtime, {
         queryContext: 'account_sync.blocklist',
-        node: (0, accountSync_1.buildAccountBlocklistSyncIq)(),
+        node: (0, account_sync_1.buildAccountBlocklistSyncIq)(),
         logMessage: 'account_sync blocklist synchronized'
     });
 }
-async function syncAccountNoticeDirtyBit(runtime) {
-    runtime.logger.info('account_sync notice protocol received (no GraphQL/MEX job configured)');
-}
 async function syncGroupsDirtyBit(runtime) {
     await runSyncQuery(runtime, {
         queryContext: 'dirty.groups',
         assertContext: 'groups',
-        node: (0, accountSync_1.buildGroupsDirtySyncIq)(),
+        node: (0, account_sync_1.buildGroupsDirtySyncIq)(),
         logMessage: 'groups dirty sync completed'
     });
 }
 async function syncNewsletterMetadataDirtyBit(runtime) {
     runtime.logger.info('newsletter_metadata dirty bit received (GraphQL/MEX sync intentionally disabled)');
-    await runtime.queryWithContext('dirty.newsletter_metadata', (0, accountSync_1.buildNewsletterMetadataSyncIq)(), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS);
-}
-async function generateUsyncSid() {
-    return (0, bytes_1.bytesToHex)(await (0, _crypto_1.randomBytesAsync)(8));
+    await runtime.queryWithContext('dirty.newsletter_metadata', (0, account_sync_1.buildNewsletterMetadataSyncIq)(), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS);
 }
 function resolveAccountSyncDeviceTargets(credentials) {
     if (!credentials?.meJid) {
@@ -238,7 +264,7 @@ async function runSyncQuery(runtime, args) {
 }
 async function clearDirtyBits(runtime, dirtyBits) {
     try {
-        await runtime.queryWithContext('dirty.clear', (0, accountSync_1.buildClearDirtyBitsIq)(dirtyBits), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, {
+        await runtime.queryWithContext('dirty.clear', (0, account_sync_1.buildClearDirtyBitsIq)(dirtyBits), constants_1.WA_DEFAULTS.IQ_TIMEOUT_MS, {
             count: dirtyBits.length
         });
         runtime.logger.info('dirty bits cleared', {

package/dist/client/events/chat.js

@@ -78,8 +78,7 @@ function parseChatEventFromAppStateMutation(mutation) {
             ...pickOptionalPrimitive('deviceAgentId', value.chatAssignment.deviceAgentID, 'string')
         };
     }
-    const fallbackAction = normalizeIndexAction(parsedIndex?.action) ??
-        normalizeValueActionKey(syncActionValueKey);
+    const fallbackAction = normalizeIndexAction(parsedIndex?.action) ?? normalizeValueActionKey(syncActionValueKey);
     if (!fallbackAction) {
         return null;
     }
@@ -204,10 +203,12 @@ function extractChatJid(parts) {
     return undefined;
 }
 function findPresentSyncActionValueKey(value) {
-    for (const [key, keyValue] of Object.entries(value)) {
+    const valueRecord = value;
+    for (const key in valueRecord) {
         if (key === 'timestamp') {
             continue;
         }
+        const keyValue = valueRecord[key];
         if (keyValue === null || keyValue === undefined) {
             continue;
         }

package/dist/client/events/devices.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEVICE_NOTIFICATION_ACTIONS = void 0;
+exports.parseDeviceNotification = parseDeviceNotification;
+const jid_1 = require("../../protocol/jid");
+const helpers_1 = require("../../transport/node/helpers");
+exports.DEVICE_NOTIFICATION_ACTIONS = Object.freeze({
+    ADD: 'add',
+    REMOVE: 'remove',
+    UPDATE: 'update'
+});
+function parseDeviceNotification(node) {
+    const stanzaId = node.attrs.id;
+    const fromJid = node.attrs.from;
+    if (!stanzaId || !fromJid) {
+        return null;
+    }
+    let action;
+    let actionNode;
+    if ((0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.REMOVE)) {
+        action = exports.DEVICE_NOTIFICATION_ACTIONS.REMOVE;
+        actionNode = (0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.REMOVE);
+    }
+    else if ((0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.ADD)) {
+        action = exports.DEVICE_NOTIFICATION_ACTIONS.ADD;
+        actionNode = (0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.ADD);
+    }
+    else if ((0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE)) {
+        action = exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE;
+        actionNode = (0, helpers_1.findNodeChild)(node, exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE);
+    }
+    else {
+        return null;
+    }
+    const devices = [];
+    if (action !== exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE && actionNode) {
+        const deviceNodes = (0, helpers_1.getNodeChildrenByTag)(actionNode, 'device');
+        for (let index = 0; index < deviceNodes.length; index += 1) {
+            const deviceNode = deviceNodes[index];
+            const jidAttr = deviceNode.attrs.jid;
+            if (!jidAttr) {
+                continue;
+            }
+            let deviceId;
+            try {
+                deviceId = (0, jid_1.parseSignalAddressFromJid)(jidAttr).device;
+            }
+            catch {
+                continue;
+            }
+            const keyIndexAttr = deviceNode.attrs['key-index'];
+            const parsedKeyIndex = keyIndexAttr === undefined ? null : Number.parseInt(keyIndexAttr, 10);
+            const keyIndex = parsedKeyIndex !== null &&
+                Number.isSafeInteger(parsedKeyIndex) &&
+                parsedKeyIndex >= 0
+                ? parsedKeyIndex
+                : null;
+            devices[devices.length] = {
+                deviceId,
+                keyIndex
+            };
+        }
+    }
+    return {
+        action,
+        stanzaId,
+        fromJid,
+        lid: node.attrs.lid,
+        hash: action === exports.DEVICE_NOTIFICATION_ACTIONS.UPDATE ? actionNode?.attrs.hash : undefined,
+        devices
+    };
+}