zapo-js 0.2.0 → 1.0.0

package/dist/esm/message/incoming.js

@@ -1,325 +0,0 @@
-import { unwrapDeviceSentMessage } from './device-sent.js';
-import { unpadPkcs7 } from './padding.js';
-import { proto } from '../proto.js';
-import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES } from '../protocol/constants.js';
-import { isBroadcastJid, isGroupJid, parseSignalAddressFromJid } from '../protocol/jid.js';
-import { buildAckNode, buildReceiptNode } from '../transport/node/builders/global.js';
-import { decodeNodeContentBase64OrBytes, findNodeChild } from '../transport/node/helpers.js';
-import { parseOptionalInt, toError } from '../util/primitives.js';
-function pickNextRetryCount(node) {
-    const retryNode = findNodeChild(node, 'retry');
-    const parsed = parseOptionalInt(retryNode?.attrs.count);
-    if (!parsed || parsed < 1) {
-        return 1;
-    }
-    return parsed + 1;
-}
-function buildIncomingEventRawNode(node) {
-    const nodeContent = node.content;
-    if (!Array.isArray(nodeContent) || nodeContent.length === 0) {
-        return node;
-    }
-    let children = null;
-    for (let index = 0; index < nodeContent.length; index += 1) {
-        const child = nodeContent[index];
-        const shouldRedact = child.tag === WA_MESSAGE_TAGS.ENC &&
-            (typeof child.content === 'string' || child.content instanceof Uint8Array);
-        if (!shouldRedact) {
-            if (children) {
-                children.push(child);
-            }
-            continue;
-        }
-        if (!children) {
-            children = nodeContent.slice(0, index);
-        }
-        children.push({
-            tag: child.tag,
-            attrs: child.attrs
-        });
-    }
-    if (!children) {
-        return node;
-    }
-    // Strip heavy encrypted payload from event snapshots to reduce retention.
-    return {
-        tag: node.tag,
-        attrs: node.attrs,
-        content: children
-    };
-}
-function buildBaseIncomingEvent(node) {
-    return {
-        rawNode: buildIncomingEventRawNode(node),
-        stanzaId: node.attrs.id,
-        chatJid: node.attrs.from,
-        stanzaType: node.attrs.type
-    };
-}
-function pickSenderKeyDistributionPayload(message) {
-    const direct = pickDirectSenderKeyDistributionPayload(message);
-    if (direct) {
-        return direct;
-    }
-    const nestedMessage = message.deviceSentMessage?.message ?? undefined;
-    if (nestedMessage) {
-        return pickSenderKeyDistributionPayload(nestedMessage);
-    }
-    return null;
-}
-function pickDirectSenderKeyDistributionPayload(message) {
-    const senderKeyDistribution = message.senderKeyDistributionMessage;
-    if (senderKeyDistribution?.groupId &&
-        senderKeyDistribution.axolotlSenderKeyDistributionMessage) {
-        return {
-            groupId: senderKeyDistribution.groupId,
-            payload: senderKeyDistribution.axolotlSenderKeyDistributionMessage
-        };
-    }
-    const fastRatchetSenderKeyDistribution = message.fastRatchetKeySenderKeyDistributionMessage;
-    if (fastRatchetSenderKeyDistribution?.groupId &&
-        fastRatchetSenderKeyDistribution.axolotlSenderKeyDistributionMessage) {
-        return {
-            groupId: fastRatchetSenderKeyDistribution.groupId,
-            payload: fastRatchetSenderKeyDistribution.axolotlSenderKeyDistributionMessage
-        };
-    }
-    return null;
-}
-function shouldEmitIncomingMessage(message) {
-    if (!pickDirectSenderKeyDistributionPayload(message)) {
-        return true;
-    }
-    const messageRecord = message;
-    for (const field in messageRecord) {
-        if (field === 'senderKeyDistributionMessage' ||
-            field === 'fastRatchetKeySenderKeyDistributionMessage' ||
-            field === '$$unknownFieldCount') {
-            continue;
-        }
-        const value = messageRecord[field];
-        if (value === null || value === undefined) {
-            continue;
-        }
-        return true;
-    }
-    return false;
-}
-async function sendRetryReceiptForDecryptFailure(node, options, error, encType) {
-    const stanzaId = node.attrs.id;
-    const from = node.attrs.from;
-    if (!stanzaId || !from) {
-        return false;
-    }
-    const retryContext = {
-        messageNode: node,
-        stanzaId,
-        from,
-        participant: node.attrs.participant,
-        recipient: node.attrs.recipient,
-        t: node.attrs.t
-    };
-    if (options.onDecryptFailure) {
-        return options.onDecryptFailure(retryContext, error);
-    }
-    const retryReceiptNode = buildReceiptNode({
-        kind: 'retry',
-        node,
-        id: stanzaId,
-        to: from,
-        retryCount: pickNextRetryCount(node)
-    });
-    try {
-        await options.sendNode(retryReceiptNode);
-        options.logger.debug('sent retry receipt for undecryptable incoming message', {
-            id: stanzaId,
-            to: from,
-            participant: retryReceiptNode.attrs.participant,
-            encType
-        });
-        return true;
-    }
-    catch (retryError) {
-        options.logger.warn('failed to send retry receipt for incoming message', {
-            id: stanzaId,
-            from,
-            participant: node.attrs.participant,
-            encType,
-            message: toError(retryError).message
-        });
-        return false;
-    }
-}
-async function decryptAndProcessEncNode(node, encNode, encType, senderJid, options, decrypt) {
-    try {
-        const senderAddress = parseSignalAddressFromJid(senderJid);
-        const decryptedPayload = await decrypt(decodeNodeContentBase64OrBytes(encNode.content, 'message.enc'), senderAddress);
-        const unpaddedPlaintext = unpadPkcs7(decryptedPayload);
-        const decodedMessage = proto.Message.decode(unpaddedPlaintext);
-        const message = unwrapDeviceSentMessage(decodedMessage) ?? decodedMessage;
-        const senderKeyDistribution = pickSenderKeyDistributionPayload(message);
-        if (senderKeyDistribution && options.senderKeyManager) {
-            try {
-                await options.senderKeyManager.processSenderKeyDistributionPayload(senderKeyDistribution.groupId, senderAddress, senderKeyDistribution.payload);
-                options.logger.debug('processed incoming sender key distribution', {
-                    id: node.attrs.id,
-                    from: node.attrs.from,
-                    participant: node.attrs.participant,
-                    groupId: senderKeyDistribution.groupId
-                });
-            }
-            catch (error) {
-                options.logger.warn('failed to process incoming sender key distribution', {
-                    id: node.attrs.id,
-                    from: node.attrs.from,
-                    participant: node.attrs.participant,
-                    groupId: senderKeyDistribution.groupId,
-                    message: toError(error).message
-                });
-            }
-        }
-        if (shouldEmitIncomingMessage(message)) {
-            const chatJid = node.attrs.from;
-            options.emitIncomingMessage?.({
-                ...buildBaseIncomingEvent(node),
-                timestampSeconds: parseOptionalInt(node.attrs.t),
-                senderJid,
-                encryptionType: encType,
-                isGroupChat: chatJid ? isGroupJid(chatJid) : false,
-                isBroadcastChat: chatJid ? isBroadcastJid(chatJid) : false,
-                plaintext: unpaddedPlaintext,
-                message
-            });
-        }
-        return { success: true, encType };
-    }
-    catch (error) {
-        options.logger.warn('failed to decrypt incoming message', {
-            id: node.attrs.id,
-            from: node.attrs.from,
-            participant: node.attrs.participant,
-            encType,
-            message: toError(error).message
-        });
-        options.emitUnhandledStanza?.({
-            ...buildBaseIncomingEvent(node),
-            reason: `message.decrypt_failed.${encType}`
-        });
-        return { success: false, encType, error };
-    }
-}
-export async function handleIncomingMessageAck(node, options) {
-    if (node.tag !== WA_MESSAGE_TAGS.MESSAGE) {
-        return false;
-    }
-    let shouldSendStandardReceipt = true;
-    const nodeContent = node.content;
-    if (Array.isArray(nodeContent) && nodeContent.length > 0) {
-        const senderJid = node.attrs.participant ?? node.attrs.from;
-        let hasSuccessfulDecrypt = false;
-        let firstDecryptFailure = null;
-        let encCount = 0;
-        let firstEncType;
-        for (const child of nodeContent) {
-            if (child.tag !== WA_MESSAGE_TAGS.ENC) {
-                continue;
-            }
-            encCount += 1;
-            if (firstEncType === undefined) {
-                firstEncType = child.attrs.type;
-            }
-            let result = null;
-            switch (child.attrs.type) {
-                case 'skmsg': {
-                    if (!senderJid || !node.attrs.from || !options.senderKeyManager) {
-                        options.emitUnhandledStanza?.({
-                            ...buildBaseIncomingEvent(node),
-                            reason: 'message.skmsg.missing_group_context'
-                        });
-                        continue;
-                    }
-                    const groupId = node.attrs.from;
-                    result = await decryptAndProcessEncNode(node, child, 'skmsg', senderJid, options, (ciphertext, senderAddress) => options.senderKeyManager.decryptGroupMessage({
-                        groupId,
-                        sender: senderAddress,
-                        ciphertext
-                    }));
-                    break;
-                }
-                case 'msg':
-                case 'pkmsg': {
-                    if (!senderJid || !options.signalProtocol) {
-                        continue;
-                    }
-                    const encType = child.attrs.type === 'msg' ? 'msg' : 'pkmsg';
-                    result = await decryptAndProcessEncNode(node, child, encType, senderJid, options, (ciphertext, senderAddress) => options.signalProtocol.decryptMessage(senderAddress, {
-                        type: encType,
-                        ciphertext
-                    }));
-                    break;
-                }
-                default:
-                    continue;
-            }
-            if (result.success)
-                hasSuccessfulDecrypt = true;
-            else if (!firstDecryptFailure)
-                firstDecryptFailure = result;
-        }
-        if (encCount > 1 && firstEncType === 'skmsg') {
-            options.logger.warn('incoming message enc order is unexpected: skmsg first', {
-                id: node.attrs.id,
-                from: node.attrs.from,
-                participant: node.attrs.participant,
-                encCount
-            });
-        }
-        if (encCount > 0 && !hasSuccessfulDecrypt && firstDecryptFailure) {
-            shouldSendStandardReceipt = !(await sendRetryReceiptForDecryptFailure(node, options, firstDecryptFailure.error, firstDecryptFailure.encType));
-        }
-    }
-    const id = node.attrs.id;
-    const from = node.attrs.from;
-    if (!id || !from) {
-        options.logger.warn('incoming message missing required attrs for ack/receipt', {
-            hasId: Boolean(id),
-            hasFrom: Boolean(from),
-            type: node.attrs.type
-        });
-        return true;
-    }
-    if (node.attrs.type === WA_MESSAGE_TYPES.MEDIA_NOTIFY) {
-        const ackNode = buildAckNode({
-            kind: 'message',
-            node,
-            id,
-            to: from,
-            from: options.getMeJid?.()
-        });
-        options.logger.debug('sending inbound message ack', {
-            id,
-            to: from,
-            type: ackNode.attrs.type,
-            participant: ackNode.attrs.participant
-        });
-        await options.sendNode(ackNode);
-        return true;
-    }
-    if (!shouldSendStandardReceipt) {
-        return true;
-    }
-    const receiptNode = buildReceiptNode({
-        kind: 'delivery',
-        node,
-        id,
-        to: from
-    });
-    options.logger.debug('sending inbound message receipt', {
-        id,
-        to: from,
-        type: receiptNode.attrs.type,
-        participant: receiptNode.attrs.participant
-    });
-    await options.sendNode(receiptNode);
-    return true;
-}

package/dist/esm/message/phash.js

@@ -1,27 +0,0 @@
-import { sha256 } from '../crypto/core/index.js';
-import { splitJid } from '../protocol/jid.js';
-import { bytesToBase64, TEXT_ENCODER } from '../util/bytes.js';
-export async function computePhashV2(participants) {
-    if (participants.length === 0) {
-        return '2:';
-    }
-    const canonical = new Array(participants.length);
-    for (let i = 0; i < participants.length; i += 1)
-        canonical[i] = toPhashCanonicalWid(participants[i]);
-    const joined = canonical.sort().join('');
-    const digest = await sha256(TEXT_ENCODER.encode(joined));
-    return `2:${bytesToBase64(digest.subarray(0, 6))}`;
-}
-function toPhashCanonicalWid(jid) {
-    const { user, server } = splitJid(jid);
-    const normalizedServer = server === 'c.us' ? 's.whatsapp.net' : server;
-    const colonIndex = user.indexOf(':');
-    const userWithOptionalAgent = colonIndex >= 0 ? user.slice(0, colonIndex) : user;
-    const baseUser = userWithOptionalAgent.endsWith('.0')
-        ? userWithOptionalAgent.slice(0, userWithOptionalAgent.length - 2)
-        : userWithOptionalAgent;
-    const deviceRaw = colonIndex >= 0 ? user.slice(colonIndex + 1) : '0';
-    const device = Number.parseInt(deviceRaw, 10);
-    const normalizedDevice = Number.isSafeInteger(device) && device >= 0 ? device : 0;
-    return `${baseUser}.0:${normalizedDevice}@${normalizedServer}`;
-}

package/dist/esm/signal/crypto/WaAdvSignature.js

@@ -1,64 +0,0 @@
-import { Ed25519, importHmacKey, hmacSign, randomBytesAsync, sha512, toRawPubKey } from '../../crypto/index.js';
-import { clampCurvePrivateKeyInPlace, montgomeryToEdwardsPublic } from '../../crypto/curves/X25519.js';
-import { encodeExtendedPoint, scalarMultBase } from '../../crypto/math/edwards.js';
-import { bytesToBigIntLE, bigIntToBytesLE } from '../../crypto/math/le.js';
-import { modGroup } from '../../crypto/math/mod.js';
-import { ADV_PREFIX_ACCOUNT_SIGNATURE, ADV_PREFIX_DEVICE_SIGNATURE, ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, ADV_PREFIX_HOSTED_DEVICE_SIGNATURE, SIGNAL_PREFIX_SIGNATURE_RANDOM } from '../crypto/constants.js';
-import { assertByteLength, concatBytes } from '../../util/bytes.js';
-export { ADV_PREFIX_ACCOUNT_SIGNATURE, ADV_PREFIX_DEVICE_SIGNATURE, ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, ADV_PREFIX_HOSTED_DEVICE_SIGNATURE } from '../crypto/constants.js';
-export async function verifySignalSignature(publicKey, message, signature) {
-    if (signature.length !== 64) {
-        return false;
-    }
-    if ((signature[63] & 0x60) !== 0) {
-        return false;
-    }
-    const signatureLastByteIndex = 63;
-    const originalSignatureLastByte = signature[signatureLastByteIndex];
-    const signBit = originalSignatureLastByte & 0x80;
-    signature[signatureLastByteIndex] = originalSignatureLastByte & 0x7f;
-    const curvePublic = toRawPubKey(publicKey);
-    const edPublic = montgomeryToEdwardsPublic(curvePublic, signBit);
-    try {
-        return await Ed25519.verify(message, signature, edPublic);
-    }
-    finally {
-        signature[signatureLastByteIndex] = originalSignatureLastByte;
-    }
-}
-export async function signSignalMessage(privateKey, message) {
-    assertByteLength(privateKey, 32, `invalid curve25519 private key length ${privateKey.length}`);
-    const clampedPrivateKey = clampCurvePrivateKeyInPlace(privateKey);
-    const privateScalar = bytesToBigIntLE(clampedPrivateKey);
-    const encodedPublic = encodeExtendedPoint(scalarMultBase(privateScalar));
-    const pubKeySignBit = encodedPublic[31] & 0x80;
-    const randomSuffix = await randomBytesAsync(64);
-    const hashInput = concatBytes([
-        SIGNAL_PREFIX_SIGNATURE_RANDOM,
-        clampedPrivateKey,
-        message,
-        randomSuffix
-    ]);
-    const r = modGroup(bytesToBigIntLE(await sha512(hashInput)));
-    const encodedR = encodeExtendedPoint(scalarMultBase(r));
-    const hInput = concatBytes([encodedR, encodedPublic, message]);
-    const h = modGroup(bytesToBigIntLE(await sha512(hInput)));
-    const s = modGroup(r + h * privateScalar);
-    const encodedS = bigIntToBytesLE(s, 32);
-    encodedS[31] = (encodedS[31] & 0x7f) | pubKeySignBit;
-    return concatBytes([encodedR, encodedS]);
-}
-export async function verifyDeviceIdentityAccountSignature(details, accountSignature, identityPublicKey, accountSignatureKey, isHosted = false) {
-    const prefix = isHosted ? ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE : ADV_PREFIX_ACCOUNT_SIGNATURE;
-    const message = concatBytes([prefix, details, identityPublicKey]);
-    return verifySignalSignature(accountSignatureKey, message, accountSignature);
-}
-export async function generateDeviceSignature(details, identityKeyPair, accountSignatureKey, isHosted = false) {
-    const prefix = isHosted ? ADV_PREFIX_HOSTED_DEVICE_SIGNATURE : ADV_PREFIX_DEVICE_SIGNATURE;
-    const message = concatBytes([prefix, details, identityKeyPair.pubKey, accountSignatureKey]);
-    return signSignalMessage(identityKeyPair.privKey, message);
-}
-export async function computeAdvIdentityHmac(secretKey, details) {
-    const key = await importHmacKey(secretKey);
-    return hmacSign(key, details);
-}

package/dist/esm/store/locks/participants.lock.js

@@ -1,20 +0,0 @@
-import { SharedExclusiveGate } from '../../infra/perf/SharedExclusiveGate.js';
-import { StoreLock } from '../../infra/perf/StoreLock.js';
-const WA_PARTICIPANTS_CLEAR_KEY = 'participants:clear';
-const WA_PARTICIPANTS_CLEANUP_KEY = 'participants:cleanup';
-export function withParticipantsLock(store) {
-    const lock = new StoreLock();
-    const gate = new SharedExclusiveGate();
-    return {
-        destroy: async () => {
-            await gate.close();
-            await lock.shutdown();
-            await store.destroy?.();
-        },
-        upsertGroupParticipants: (snapshot) => gate.runShared(() => lock.run(`participants:group:${snapshot.groupJid}`, () => store.upsertGroupParticipants(snapshot))),
-        getGroupParticipants: (groupJid, nowMs) => gate.runShared(() => store.getGroupParticipants(groupJid, nowMs)),
-        deleteGroupParticipants: (groupJid) => gate.runShared(() => lock.run(`participants:group:${groupJid}`, () => store.deleteGroupParticipants(groupJid))),
-        cleanupExpired: (nowMs) => gate.runExclusive(() => lock.run(WA_PARTICIPANTS_CLEANUP_KEY, () => store.cleanupExpired(nowMs))),
-        clear: () => gate.runExclusive(() => lock.run(WA_PARTICIPANTS_CLEAR_KEY, () => store.clear()))
-    };
-}

package/dist/esm/store/providers/memory/contact.store.js

@@ -1,28 +0,0 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { setBoundedMapEntry } from '../../../util/collections.js';
-const DEFAULT_CONTACT_MEMORY_STORE_LIMITS = Object.freeze({
-    contacts: 20000
-});
-export class WaContactMemoryStore {
-    constructor(options = {}) {
-        this.contacts = new Map();
-        this.maxContacts = resolvePositive(options.maxContacts, DEFAULT_CONTACT_MEMORY_STORE_LIMITS.contacts, 'WaContactMemoryStoreOptions.maxContacts');
-    }
-    async upsert(record) {
-        setBoundedMapEntry(this.contacts, record.jid, record, this.maxContacts);
-    }
-    async upsertBatch(records) {
-        for (const record of records) {
-            setBoundedMapEntry(this.contacts, record.jid, record, this.maxContacts);
-        }
-    }
-    async getByJid(jid) {
-        return this.contacts.get(jid) ?? null;
-    }
-    async deleteByJid(jid) {
-        return this.contacts.delete(jid) ? 1 : 0;
-    }
-    async clear() {
-        this.contacts.clear();
-    }
-}

package/dist/esm/store/providers/memory/device-list.store.js

@@ -1,64 +0,0 @@
-import { resolvePositive } from '../../../util/coercion.js';
-import { resolveCleanupIntervalMs, setBoundedMapEntry } from '../../../util/collections.js';
-const DEFAULTS = Object.freeze({
-    ttlMs: 5 * 60 * 1000,
-    maxUsers: 16384
-});
-export class WaDeviceListMemoryStore {
-    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
-        this.records = new Map();
-        this.ttlMs = ttlMs;
-        this.maxUsers = resolvePositive(options.maxUsers, DEFAULTS.maxUsers, 'WaDeviceListMemoryStoreOptions.maxUsers');
-        this.cleanupTimer = setInterval(() => {
-            void this.cleanupExpired(Date.now());
-        }, resolveCleanupIntervalMs(ttlMs));
-        this.cleanupTimer.unref();
-    }
-    async upsertUserDevicesBatch(snapshots) {
-        for (let index = 0; index < snapshots.length; index += 1) {
-            const snapshot = snapshots[index];
-            setBoundedMapEntry(this.records, snapshot.userJid, {
-                ...snapshot,
-                expiresAtMs: snapshot.updatedAtMs + this.ttlMs
-            }, this.maxUsers);
-        }
-    }
-    async getUserDevicesBatch(userJids, nowMs = Date.now()) {
-        const snapshots = new Array(userJids.length);
-        for (let index = 0; index < userJids.length; index += 1) {
-            const userJid = userJids[index];
-            const record = this.records.get(userJid);
-            if (!record) {
-                snapshots[index] = null;
-                continue;
-            }
-            if (record.expiresAtMs <= nowMs) {
-                this.records.delete(userJid);
-                snapshots[index] = null;
-                continue;
-            }
-            snapshots[index] = record;
-        }
-        return snapshots;
-    }
-    async deleteUserDevices(userJid) {
-        return this.records.delete(userJid) ? 1 : 0;
-    }
-    async cleanupExpired(nowMs) {
-        let removed = 0;
-        for (const [userJid, record] of this.records) {
-            if (record.expiresAtMs > nowMs)
-                continue;
-            this.records.delete(userJid);
-            removed += 1;
-        }
-        return removed;
-    }
-    async clear() {
-        this.records.clear();
-    }
-    async destroy() {
-        clearInterval(this.cleanupTimer);
-        await this.clear();
-    }
-}