zapo-js 0.1.0

package/dist/esm/message/WaMessageClient.js

@@ -0,0 +1,210 @@
+import { describeAckNode, isAckOrReceiptNode, isNegativeAckNode, isRetryableNegativeAck } from './ack.js';
+import { WA_DEFAULTS, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_NODE_TAGS } from '../protocol/constants.js';
+import { parseOptionalInt } from '../transport/stream/parse.js';
+import { delay } from '../util/async.js';
+import { toError } from '../util/primitives.js';
+class MessagePublishNackError extends Error {
+    constructor(message, retryable) {
+        super(message);
+        this.name = 'MessagePublishNackError';
+        this.retryable = retryable;
+    }
+}
+export class WaMessageClient {
+    constructor(options) {
+        this.logger = options.logger;
+        this.sendNode = options.sendNode;
+        this.query = options.query;
+        this.defaultAckTimeoutMs = options.defaultAckTimeoutMs ?? WA_DEFAULTS.MESSAGE_ACK_TIMEOUT_MS;
+        this.defaultMaxAttempts = options.defaultMaxAttempts ?? WA_DEFAULTS.MESSAGE_MAX_ATTEMPTS;
+        this.defaultRetryDelayMs = options.defaultRetryDelayMs ?? WA_DEFAULTS.MESSAGE_RETRY_DELAY_MS;
+    }
+    async publishNode(node, options = {}) {
+        if (node.tag !== WA_MESSAGE_TAGS.MESSAGE) {
+            throw new Error(`invalid node tag for message publish: ${node.tag}`);
+        }
+        const ackTimeoutMs = options.ackTimeoutMs ?? this.defaultAckTimeoutMs;
+        const maxAttempts = options.maxAttempts ?? this.defaultMaxAttempts;
+        const retryDelayMs = options.retryDelayMs ?? this.defaultRetryDelayMs;
+        if (ackTimeoutMs < 1 || maxAttempts < 1 || retryDelayMs < 0) {
+            throw new Error('invalid message publish options');
+        }
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            try {
+                this.logger.debug('message publish attempt', {
+                    attempt,
+                    maxAttempts,
+                    to: node.attrs.to,
+                    type: node.attrs.type,
+                    id: node.attrs.id
+                });
+                const ackNode = await this.query(node, ackTimeoutMs);
+                const id = ackNode.attrs.id;
+                if (!id) {
+                    throw new Error('message publish ack node missing id');
+                }
+                if (!isAckOrReceiptNode(ackNode)) {
+                    throw new Error(`unexpected publish response: ${describeAckNode(ackNode)}`);
+                }
+                if (isNegativeAckNode(ackNode)) {
+                    throw new MessagePublishNackError(`negative publish ack: ${describeAckNode(ackNode)}`, isRetryableNegativeAck(ackNode));
+                }
+                this.logger.info('message publish acknowledged', {
+                    id,
+                    tag: ackNode.tag,
+                    type: ackNode.attrs.type,
+                    phash: ackNode.attrs.phash,
+                    addressingMode: ackNode.attrs.addressing_mode,
+                    attempts: attempt
+                });
+                return {
+                    id,
+                    attempts: attempt,
+                    ackNode,
+                    ack: this.extractAckMetadata(ackNode)
+                };
+            }
+            catch (error) {
+                lastError = toError(error);
+                const nackRetryable = error instanceof MessagePublishNackError ? error.retryable : false;
+                const canRetry = attempt < maxAttempts &&
+                    (this.isRetryablePublishError(lastError) || nackRetryable);
+                this.logger.warn('message publish attempt failed', {
+                    attempt,
+                    maxAttempts,
+                    canRetry,
+                    nackRetryable,
+                    message: lastError.message
+                });
+                if (!canRetry) {
+                    throw lastError;
+                }
+                await delay(retryDelayMs * attempt);
+            }
+        }
+        throw lastError ?? new Error('message publish failed');
+    }
+    async publishEncrypted(input, options = {}) {
+        const node = this.buildEncryptedMessageNode(input);
+        return this.publishNode(node, options);
+    }
+    async sendMessageNode(node) {
+        if (node.tag !== WA_MESSAGE_TAGS.MESSAGE) {
+            throw new Error(`invalid node tag for message send: ${node.tag}`);
+        }
+        this.logger.debug('message sent without waiting for ack', {
+            to: node.attrs.to,
+            type: node.attrs.type,
+            id: node.attrs.id
+        });
+        await this.sendNode(node);
+    }
+    async sendEncrypted(input) {
+        const node = this.buildEncryptedMessageNode(input);
+        this.logger.debug('encrypted message sent without waiting for ack', {
+            to: node.attrs.to,
+            type: node.attrs.type,
+            id: node.attrs.id
+        });
+        await this.sendNode(node);
+    }
+    buildEncryptedMessageNode(input) {
+        const attrs = {
+            to: input.to,
+            type: input.type ?? 'text'
+        };
+        if (input.id) {
+            attrs.id = input.id;
+        }
+        if (input.category) {
+            attrs.category = input.category;
+        }
+        if (input.pushPriority) {
+            attrs.push_priority = input.pushPriority;
+        }
+        if (input.participant) {
+            attrs.participant = input.participant;
+        }
+        if (input.addressingMode) {
+            attrs.addressing_mode = input.addressingMode;
+        }
+        if (input.deviceFanout) {
+            attrs.device_fanout = input.deviceFanout;
+        }
+        const encAttrs = {
+            v: WA_MESSAGE_TYPES.ENC_VERSION,
+            type: input.encType
+        };
+        if (input.encCount !== undefined && input.encCount > 0) {
+            encAttrs.count = String(Math.trunc(input.encCount));
+        }
+        const content = [
+            {
+                tag: WA_MESSAGE_TAGS.ENC,
+                attrs: encAttrs,
+                content: input.ciphertext
+            }
+        ];
+        if (input.deviceIdentity) {
+            content.push({
+                tag: WA_NODE_TAGS.DEVICE_IDENTITY,
+                attrs: {},
+                content: input.deviceIdentity
+            });
+        }
+        const node = {
+            tag: WA_MESSAGE_TAGS.MESSAGE,
+            attrs,
+            content
+        };
+        return node;
+    }
+    async sendReceipt(input) {
+        const attrs = {
+            to: input.to,
+            id: input.id,
+            type: input.type ?? 'read'
+        };
+        if (input.participant) {
+            attrs.participant = input.participant;
+        }
+        if (input.from) {
+            attrs.from = input.from;
+        }
+        if (input.t) {
+            attrs.t = input.t;
+        }
+        this.logger.debug('sending receipt node', {
+            to: attrs.to,
+            id: attrs.id,
+            type: attrs.type
+        });
+        await this.sendNode({
+            tag: WA_MESSAGE_TAGS.RECEIPT,
+            attrs
+        });
+    }
+    isRetryablePublishError(error) {
+        const message = error.message.toLowerCase();
+        return (message.includes('timeout') ||
+            message.includes('socket') ||
+            message.includes('connection') ||
+            message.includes('closed'));
+    }
+    extractAckMetadata(ackNode) {
+        const addressingModeRaw = ackNode.attrs.addressing_mode;
+        const addressingMode = addressingModeRaw === 'pn' || addressingModeRaw === 'lid'
+            ? addressingModeRaw
+            : undefined;
+        return {
+            t: ackNode.attrs.t,
+            sync: ackNode.attrs.sync,
+            phash: ackNode.attrs.phash,
+            refreshLid: ackNode.attrs.refresh_lid === 'true',
+            addressingMode,
+            count: parseOptionalInt(ackNode.attrs.count),
+            error: parseOptionalInt(ackNode.attrs.error)
+        };
+    }
+}

package/dist/esm/message/ack.js

@@ -0,0 +1,46 @@
+import { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from '../protocol/constants.js';
+export function isAckOrReceiptNode(node) {
+    return node.tag === WA_MESSAGE_TAGS.ACK || node.tag === WA_MESSAGE_TAGS.RECEIPT;
+}
+export function isNegativeAckNode(node) {
+    if (node.tag === WA_MESSAGE_TAGS.ERROR) {
+        return true;
+    }
+    if (node.tag !== WA_MESSAGE_TAGS.ACK) {
+        return false;
+    }
+    const ackType = node.attrs.type;
+    const ackClass = node.attrs.class;
+    return (ackType === WA_MESSAGE_TYPES.ACK_TYPE_ERROR || ackClass === WA_MESSAGE_TYPES.ACK_CLASS_ERROR);
+}
+export function isRetryableNegativeAck(node) {
+    const code = node.attrs.code;
+    if (code && WA_RETRYABLE_ACK_CODES.includes(code)) {
+        return true;
+    }
+    const ackType = node.attrs.type;
+    if (ackType && (ackType === 'wait' || ackType === 'retry' || ackType === 'timeout')) {
+        return true;
+    }
+    return false;
+}
+export function describeAckNode(node) {
+    const parts = [`tag=${node.tag}`];
+    const id = node.attrs.id;
+    const type = node.attrs.type;
+    const ackClass = node.attrs.class;
+    const code = node.attrs.code;
+    if (id) {
+        parts.push(`id=${id}`);
+    }
+    if (type) {
+        parts.push(`type=${type}`);
+    }
+    if (ackClass) {
+        parts.push(`class=${ackClass}`);
+    }
+    if (code) {
+        parts.push(`code=${code}`);
+    }
+    return parts.join(' ');
+}

package/dist/esm/message/content.js

@@ -0,0 +1,20 @@
+export function isSendMediaMessage(content) {
+    return (!!content &&
+        typeof content === 'object' &&
+        'type' in content &&
+        'media' in content &&
+        'mimetype' in content);
+}
+export function resolveMessageTypeAttr(message) {
+    if (message.reactionMessage) {
+        return 'reaction';
+    }
+    if (message.imageMessage ||
+        message.videoMessage ||
+        message.audioMessage ||
+        message.documentMessage ||
+        message.stickerMessage) {
+        return 'media';
+    }
+    return 'text';
+}

package/dist/esm/message/device-sent.js

@@ -0,0 +1,49 @@
+export function wrapDeviceSentMessage(message, destinationJid) {
+    if (!destinationJid || destinationJid.trim().length === 0) {
+        throw new Error('device sent destinationJid must be a non-empty string');
+    }
+    if (message.deviceSentMessage) {
+        return message;
+    }
+    const rootContext = message.messageContextInfo ?? undefined;
+    if (!rootContext) {
+        return {
+            deviceSentMessage: {
+                destinationJid,
+                message
+            }
+        };
+    }
+    return {
+        messageContextInfo: {
+            ...rootContext
+        },
+        deviceSentMessage: {
+            destinationJid,
+            message: {
+                ...message,
+                messageContextInfo: undefined
+            }
+        }
+    };
+}
+export function unwrapDeviceSentMessage(message) {
+    const nested = message.deviceSentMessage?.message ?? undefined;
+    if (!nested) {
+        return null;
+    }
+    const nestedContext = nested.messageContextInfo ?? undefined;
+    const rootContext = message.messageContextInfo ?? undefined;
+    const mergedContext = {
+        ...(nestedContext ?? {}),
+        messageSecret: nestedContext?.messageSecret ?? rootContext?.messageSecret,
+        messageAssociation: nestedContext?.messageAssociation ?? rootContext?.messageAssociation,
+        limitSharingV2: rootContext?.limitSharingV2 ?? nestedContext?.limitSharingV2,
+        threadId: nestedContext?.threadId ?? rootContext?.threadId ?? [],
+        botMetadata: nestedContext?.botMetadata ?? rootContext?.botMetadata
+    };
+    return {
+        ...nested,
+        messageContextInfo: mergedContext
+    };
+}

package/dist/esm/message/incoming.js

@@ -0,0 +1,318 @@
+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 { buildInboundDeliveryReceiptNode, buildInboundMessageAckNode, buildInboundRetryReceiptNode } from '../transport/node/builders/message.js';
+import { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildrenByTag } from '../transport/node/helpers.js';
+import { toError } from '../util/primitives.js';
+function pickMessageSenderJid(node) {
+    return node.attrs.participant ?? node.attrs.from;
+}
+function pickMessageChatJid(node) {
+    return node.attrs.from;
+}
+function parseMessageTimestamp(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isSafeInteger(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+function pickNextRetryCount(node) {
+    const retryNode = findNodeChild(node, 'retry');
+    const countRaw = retryNode?.attrs.count;
+    if (!countRaw) {
+        return 1;
+    }
+    const parsed = Number.parseInt(countRaw, 10);
+    if (!Number.isSafeInteger(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 redacted = false;
+    const children = nodeContent.map((child) => {
+        if (child.tag !== WA_MESSAGE_TAGS.ENC) {
+            return child;
+        }
+        if (typeof child.content === 'string' || child.content instanceof Uint8Array) {
+            redacted = true;
+            return {
+                tag: child.tag,
+                attrs: child.attrs
+            };
+        }
+        return child;
+    });
+    if (!redacted) {
+        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;
+    }
+    for (const [field, value] of Object.entries(message)) {
+        if (value === null || value === undefined) {
+            continue;
+        }
+        if (field === 'senderKeyDistributionMessage' ||
+            field === 'fastRatchetKeySenderKeyDistributionMessage' ||
+            field === '$$unknownFieldCount') {
+            continue;
+        }
+        return true;
+    }
+    return false;
+}
+async function maybeProcessSenderKeyDistributionMessage(senderJid, message, options, node) {
+    if (!senderJid || !options.senderKeyManager) {
+        return;
+    }
+    const senderKeyDistribution = pickSenderKeyDistributionPayload(message);
+    if (!senderKeyDistribution) {
+        return;
+    }
+    try {
+        await options.senderKeyManager.processSenderKeyDistributionPayload(senderKeyDistribution.groupId, parseSignalAddressFromJid(senderJid), 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
+        });
+    }
+}
+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 = buildInboundRetryReceiptNode(node, stanzaId, from, options.getMeJid?.(), 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 decryptedPayload = await decrypt(decodeNodeContentBase64OrBytes(encNode.content, 'message.enc'));
+        const unpaddedPlaintext = unpadPkcs7(decryptedPayload);
+        const message = normalizeIncomingDecryptedMessage(proto.Message.decode(unpaddedPlaintext));
+        await maybeProcessSenderKeyDistributionMessage(senderJid, message, options, node);
+        if (shouldEmitIncomingMessage(message)) {
+            const chatJid = pickMessageChatJid(node);
+            options.emitIncomingMessage?.({
+                ...buildBaseIncomingEvent(node),
+                timestampSeconds: parseMessageTimestamp(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 encNodes = getNodeChildrenByTag(node, WA_MESSAGE_TAGS.ENC);
+    if (encNodes.length > 1 && encNodes[0]?.attrs.type === '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: encNodes.length
+        });
+    }
+    if (encNodes.length > 0) {
+        const senderJid = pickMessageSenderJid(node);
+        const chatJid = pickMessageChatJid(node);
+        let hasSuccessfulDecrypt = false;
+        let firstDecryptFailure = null;
+        for (const encNode of encNodes) {
+            const encType = encNode.attrs.type;
+            if (!encType) {
+                continue;
+            }
+            if (encType === 'skmsg') {
+                if (!senderJid || !chatJid || !options.senderKeyManager) {
+                    options.emitUnhandledStanza?.({
+                        ...buildBaseIncomingEvent(node),
+                        reason: 'message.skmsg.missing_group_context'
+                    });
+                    continue;
+                }
+                const result = await decryptAndProcessEncNode(node, encNode, encType, senderJid, options, (ciphertext) => options.senderKeyManager.decryptGroupMessage({
+                    groupId: chatJid,
+                    sender: parseSignalAddressFromJid(senderJid),
+                    ciphertext
+                }));
+                if (result.success) {
+                    hasSuccessfulDecrypt = true;
+                }
+                else if (!firstDecryptFailure) {
+                    firstDecryptFailure = result;
+                }
+                continue;
+            }
+            if ((encType === 'msg' || encType === 'pkmsg') && senderJid && options.signalProtocol) {
+                const result = await decryptAndProcessEncNode(node, encNode, encType, senderJid, options, (ciphertext) => options.signalProtocol.decryptMessage(parseSignalAddressFromJid(senderJid), { type: encType, ciphertext }));
+                if (result.success) {
+                    hasSuccessfulDecrypt = true;
+                }
+                else if (!firstDecryptFailure) {
+                    firstDecryptFailure = result;
+                }
+            }
+        }
+        if (!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 = buildInboundMessageAckNode(node, id, 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 = buildInboundDeliveryReceiptNode(node, id, 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;
+}
+function normalizeIncomingDecryptedMessage(message) {
+    return unwrapDeviceSentMessage(message) ?? message;
+}

package/dist/esm/message/index.js

@@ -0,0 +1,2 @@
+export { WaMessageClient } from './WaMessageClient.js';
+export * from './types.js';

package/dist/esm/message/padding.js

@@ -0,0 +1,20 @@
+import { randomBytesAsync } from '../crypto/index.js';
+const RANDOM_PAD_MAX_16_MASK = 0x0f;
+export async function writeRandomPadMax16(message) {
+    const padSeed = await randomBytesAsync(1);
+    const padLength = (padSeed[0] & RANDOM_PAD_MAX_16_MASK) + 1;
+    const out = new Uint8Array(message.length + padLength);
+    out.set(message, 0);
+    out.fill(padLength, message.length);
+    return out;
+}
+export function unpadPkcs7(bytes) {
+    if (bytes.length === 0) {
+        throw new Error('unpadPkcs7 given empty bytes');
+    }
+    const padLength = bytes[bytes.length - 1];
+    if (padLength > bytes.length) {
+        throw new Error(`unpadPkcs7 given ${bytes.length} bytes, but pad is ${padLength}`);
+    }
+    return bytes.subarray(0, bytes.length - padLength);
+}

package/dist/esm/message/phash.js

@@ -0,0 +1,25 @@
+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 = participants.map((participant) => toPhashCanonicalWid(participant));
+    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}`;
+}