zapo-js 0.2.0 → 0.3.0

package/dist/esm/media/WaMediaTransferClient.js

@@ -1,10 +1,10 @@
-import { Readable } from 'node:stream';
+import http from 'node:http';
+import https from 'node:https';
 import { DEFAULT_MEDIA_HOSTS } from './constants.js';
 import { WaMediaCrypto } from './WaMediaCrypto.js';
 import { WA_DEFAULTS } from '../protocol/constants.js';
 import { EMPTY_BYTES, readAllBytes } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
-const GOT_OPTIONAL_MODULE = 'got';
 function normalizeHeaderRecord(headers) {
     if (!headers) {
         return {};
@@ -15,56 +15,6 @@ function normalizeHeaderRecord(headers) {
     }
     return normalized;
 }
-function asOptionalGotModule(loaded) {
-    if (loaded && typeof loaded === 'object') {
-        const direct = loaded.stream;
-        if (typeof direct === 'function') {
-            return loaded;
-        }
-        const fallback = loaded.default;
-        if (fallback &&
-            typeof fallback === 'object' &&
-            'stream' in fallback &&
-            typeof fallback.stream === 'function') {
-            return fallback;
-        }
-        if (typeof fallback === 'function' && 'stream' in fallback) {
-            const maybeStream = fallback.stream;
-            if (typeof maybeStream === 'function') {
-                return fallback;
-            }
-        }
-    }
-    if (typeof loaded === 'function' && 'stream' in loaded) {
-        const maybeStream = loaded.stream;
-        if (typeof maybeStream === 'function') {
-            return loaded;
-        }
-    }
-    return null;
-}
-async function loadOptionalGotModule() {
-    try {
-        const loaded = await import(GOT_OPTIONAL_MODULE);
-        const module = asOptionalGotModule(loaded);
-        if (module) {
-            return module;
-        }
-        throw new Error('invalid got module export');
-    }
-    catch (error) {
-        const normalized = toError(error);
-        const code = normalized.code;
-        const message = normalized.message ?? '';
-        const isModuleNotFound = (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') &&
-            (message.includes(`'${GOT_OPTIONAL_MODULE}'`) ||
-                message.includes(`"${GOT_OPTIONAL_MODULE}"`));
-        if (isModuleNotFound) {
-            throw new Error('optional dependency "got" is not installed. Install with: npm i got');
-        }
-        throw normalized;
-    }
-}
 export class WaMediaTransferClient {
     constructor(options = {}) {
         this.logger = options.logger;
@@ -72,25 +22,18 @@ export class WaMediaTransferClient {
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? WA_DEFAULTS.MEDIA_TIMEOUT_MS;
         this.defaultMaxReadBytes = options.defaultMaxReadBytes;
         this.defaultHeaders = normalizeHeaderRecord(options.defaultHeaders);
-        this.defaultUploadDispatcher = options.defaultUploadDispatcher;
-        this.defaultDownloadDispatcher = options.defaultDownloadDispatcher;
         this.defaultUploadAgent = options.defaultUploadAgent;
         this.defaultDownloadAgent = options.defaultDownloadAgent;
-        this.gotModulePromise = null;
+        this.skipMacVerification = options.skipMacVerification === true;
     }
     async downloadStream(request) {
         const { urls, headers, timeoutMs } = this.resolveTransferRequest(request);
-        const dispatcher = request.dispatcher ?? this.defaultDownloadDispatcher;
         const agent = request.agent ?? this.defaultDownloadAgent;
         this.logger?.debug('media download stream start', {
             urls: urls.length,
             timeoutMs
         });
-        const result = await this.fetchWithFallback(urls, timeoutMs, request.signal, (url, signal) => this.transferRequest(url, {
-            method: 'GET',
-            headers,
-            signal
-        }, dispatcher, agent));
+        const result = await this.fetchWithFallback(urls, timeoutMs, request.signal, (url, signal) => this.httpRequest(url, { method: 'GET', headers, signal }, agent));
         this.logger?.trace('media download stream response', {
             url: result.url,
             status: result.status
@@ -115,7 +58,6 @@ export class WaMediaTransferClient {
                 ? String(request.contentLength)
                 : undefined
         });
-        const dispatcher = request.dispatcher ?? this.defaultUploadDispatcher;
         const agent = request.agent ?? this.defaultUploadAgent;
         const uploadUrls = bodyIsBytes ? urls : urls.slice(0, 1);
         if (!bodyIsBytes && urls.length > 1) {
@@ -129,23 +71,7 @@ export class WaMediaTransferClient {
             timeoutMs,
             method
         });
-        const result = await this.fetchWithFallback(uploadUrls, timeoutMs, request.signal, async (url, signal) => {
-            if (bodyIsBytes) {
-                return this.transferRequest(url, {
-                    method,
-                    headers,
-                    signal,
-                    body: request.body
-                }, dispatcher, agent);
-            }
-            return this.transferRequest(url, {
-                method,
-                headers,
-                signal,
-                body: request.body,
-                duplex: 'half'
-            }, dispatcher, agent);
-        });
+        const result = await this.fetchWithFallback(uploadUrls, timeoutMs, request.signal, (url, signal) => this.httpRequest(url, { method, headers, signal, body: request.body }, agent));
         this.logger?.trace('media upload stream response', {
             url: result.url,
             status: result.status
@@ -165,7 +91,6 @@ export class WaMediaTransferClient {
                 directPath: request.directPath,
                 hosts: request.hosts,
                 headers: request.headers,
-                dispatcher: request.dispatcher,
                 agent: request.agent,
                 timeoutMs: request.timeoutMs,
                 signal: request.signal,
@@ -221,7 +146,8 @@ export class WaMediaTransferClient {
             mediaType: request.mediaType,
             mediaKey: request.mediaKey,
             expectedFileSha256: request.fileSha256,
-            expectedFileEncSha256: request.fileEncSha256
+            expectedFileEncSha256: request.fileEncSha256,
+            skipMacVerification: this.skipMacVerification
         });
         decrypted.metadata.catch(() => undefined);
         this.logger?.debug('media encrypted download stream ready', {
@@ -238,119 +164,50 @@ export class WaMediaTransferClient {
         }
         return readAllBytes(response.body, { maxBytes: maxBytes ?? this.defaultMaxReadBytes });
     }
-    async transferRequest(url, init, dispatcher, agent) {
-        if (agent) {
-            return this.gotWithAgent(url, init, agent);
-        }
-        return this.fetchWithDispatcher(url, init, dispatcher);
-    }
-    async fetchWithDispatcher(url, init, dispatcher) {
-        const response = !dispatcher
-            ? await fetch(url, init)
-            : await fetch(url, {
-                ...init,
-                dispatcher
-            });
-        return this.toFetchTransferResponse(response);
-    }
-    toFetchTransferResponse(response) {
-        return {
-            status: response.status,
-            ok: response.ok,
-            headers: Object.fromEntries(response.headers.entries()),
-            body: response.body
-                ? Readable.fromWeb(response.body)
-                : null,
-            cancel: async () => {
-                if (!response.body) {
-                    return;
-                }
-                try {
-                    await response.body.cancel();
-                }
-                catch {
-                    // ignore cancel errors from remote resets
-                }
-            }
-        };
-    }
-    async gotWithAgent(url, init, agent) {
-        const got = await this.loadGotModule();
-        const urlObj = new URL(url);
-        const gotAgent = urlObj.protocol === 'http:'
-            ? { http: agent }
-            : urlObj.protocol === 'https:'
-                ? { https: agent }
-                : { http: agent, https: agent };
+    async httpRequest(url, init, agent) {
+        const parsed = new URL(url);
+        const transport = parsed.protocol === 'https:' ? https : http;
         return new Promise((resolve, reject) => {
-            const request = got.stream(url, {
-                method: init.method,
-                headers: (init.headers ?? {}),
-                body: init.body,
-                signal: init.signal,
-                throwHttpErrors: false,
-                retry: { limit: 0 },
-                agent: gotAgent
-            });
-            const onError = (error) => {
-                request.off('response', onResponse);
-                reject(toError(error));
-            };
-            const onResponse = (incoming) => {
-                request.off('error', onError);
-                resolve(this.toGotTransferResponse(incoming));
-            };
-            request.once('error', onError);
-            request.once('response', onResponse);
-        });
-    }
-    async loadGotModule() {
-        if (!this.gotModulePromise) {
-            this.gotModulePromise = loadOptionalGotModule().catch((error) => {
-                this.gotModulePromise = null;
-                throw error;
-            });
-        }
-        return this.gotModulePromise;
-    }
-    toGotTransferResponse(incoming) {
-        if (!incoming || typeof incoming !== 'object') {
-            throw new Error('invalid got response object');
-        }
-        const stream = incoming;
-        const status = typeof stream.statusCode === 'number' &&
-            Number.isFinite(stream.statusCode) &&
-            stream.statusCode >= 100 &&
-            stream.statusCode <= 599
-            ? stream.statusCode
-            : 500;
-        const headers = {};
-        if (stream.headers && typeof stream.headers === 'object') {
-            const input = stream.headers;
-            for (const key in input) {
-                const value = input[key];
-                if (typeof value === 'string') {
-                    headers[key] = value;
-                    continue;
-                }
-                if (Array.isArray(value)) {
-                    headers[key] = value.join(', ');
-                    continue;
-                }
-                if (value !== undefined && value !== null) {
-                    headers[key] = String(value);
+            const req = transport.request(url, {
+                method: init.method ?? 'GET',
+                headers: init.headers,
+                signal: init.signal ?? undefined,
+                agent: agent ?? undefined
+            }, (res) => {
+                const status = res.statusCode ?? 500;
+                const headers = {};
+                for (const key in res.headers) {
+                    const value = res.headers[key];
+                    if (typeof value === 'string') {
+                        headers[key] = value;
+                    }
+                    else if (Array.isArray(value)) {
+                        headers[key] = value.join(', ');
+                    }
                 }
+                resolve({
+                    status,
+                    ok: status >= 200 && status < 300,
+                    headers,
+                    body: res,
+                    cancel: async () => {
+                        res.destroy();
+                    }
+                });
+            });
+            req.on('error', (error) => reject(toError(error)));
+            const body = init.body;
+            if (body instanceof Uint8Array) {
+                req.end(body);
             }
-        }
-        return {
-            status,
-            ok: status >= 200 && status < 300,
-            headers,
-            body: stream,
-            cancel: async () => {
-                stream.destroy();
+            else if (body) {
+                body.on('error', (err) => req.destroy(toError(err)));
+                body.pipe(req);
             }
-        };
+            else {
+                req.end();
+            }
+        });
     }
     resolveTransferRequest(request, extraHeaders) {
         const headers = { ...this.defaultHeaders };

package/dist/esm/media/constants.js

@@ -10,6 +10,8 @@ export const ENC_KEY_END = 48;
 export const MAC_KEY_START = 48;
 export const MAC_KEY_END = 80;
 export const HMAC_TRUNCATED_SIZE = 10;
+export const SIDECAR_CHUNK_SIZE = 65536;
+export const SIDECAR_HMAC_SIZE = 10;
 export const MEDIA_UPLOAD_PATHS = Object.freeze({
     image: '/mms/image',
     video: '/mms/video',

package/dist/esm/media/processor.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/message/addon-crypto.js

@@ -1,6 +1,8 @@
-import { aesGcmDecrypt, aesGcmEncrypt, importAesGcmKey } from '../crypto/index.js';
-import { assertMessageSecret, createUseCaseSecret, WA_USE_CASE_SECRET_MODIFICATION_TYPES } from './use-case-secret.js';
-import { EMPTY_BYTES, TEXT_ENCODER, toBytesView } from '../util/bytes.js';
+import { aesGcmDecrypt, aesGcmEncrypt, importAesGcmKey, sha256 } from '../crypto/index.js';
+import { unwrapMessage } from './content.js';
+import { assertMessageSecret, createUseCaseSecret, WA_MESSAGE_SECRET_BYTES, WA_USE_CASE_SECRET_MODIFICATION_TYPES } from './use-case-secret.js';
+import { proto } from '../proto.js';
+import { bytesToHex, EMPTY_BYTES, TEXT_ENCODER, toBytesView } from '../util/bytes.js';
 const WA_ADDON_ENCRYPTION_NONCE_BYTES = 12;
 export function shouldUseAddonAdditionalData(modificationType) {
     return (modificationType === WA_USE_CASE_SECRET_MODIFICATION_TYPES.POLL_VOTE ||
@@ -41,6 +43,131 @@ export async function decryptAddonPayload(input) {
     const additionalData = resolveAddonAdditionalData(input);
     return aesGcmDecrypt(key, iv, toBytesView(input.ciphertext), additionalData);
 }
+export function identifyEncryptedAddon(message) {
+    const msg = unwrapMessage(message);
+    if (msg.encReactionMessage) {
+        const { targetMessageKey, encPayload, encIv } = msg.encReactionMessage;
+        if (targetMessageKey && encPayload && encIv) {
+            return {
+                kind: 'reaction',
+                targetMessageKey,
+                encPayload: encPayload,
+                encIv: encIv,
+                modificationType: WA_USE_CASE_SECRET_MODIFICATION_TYPES.ENC_REACTION,
+                raw: message
+            };
+        }
+    }
+    if (msg.pollUpdateMessage) {
+        const { pollCreationMessageKey, vote } = msg.pollUpdateMessage;
+        if (pollCreationMessageKey && vote?.encPayload && vote.encIv) {
+            return {
+                kind: 'poll_vote',
+                targetMessageKey: pollCreationMessageKey,
+                encPayload: vote.encPayload,
+                encIv: vote.encIv,
+                modificationType: WA_USE_CASE_SECRET_MODIFICATION_TYPES.POLL_VOTE,
+                raw: message
+            };
+        }
+    }
+    if (msg.encEventResponseMessage) {
+        const { eventCreationMessageKey, encPayload, encIv } = msg.encEventResponseMessage;
+        if (eventCreationMessageKey && encPayload && encIv) {
+            return {
+                kind: 'event_response',
+                targetMessageKey: eventCreationMessageKey,
+                encPayload: encPayload,
+                encIv: encIv,
+                modificationType: WA_USE_CASE_SECRET_MODIFICATION_TYPES.EVENT_RESPONSE,
+                raw: message
+            };
+        }
+    }
+    if (msg.encCommentMessage) {
+        const { targetMessageKey, encPayload, encIv } = msg.encCommentMessage;
+        if (targetMessageKey && encPayload && encIv) {
+            return {
+                kind: 'comment',
+                targetMessageKey,
+                encPayload: encPayload,
+                encIv: encIv,
+                modificationType: WA_USE_CASE_SECRET_MODIFICATION_TYPES.ENC_COMMENT,
+                raw: message
+            };
+        }
+    }
+    return null;
+}
+export function decodeAddonPlaintext(kind, plaintext) {
+    switch (kind) {
+        case 'reaction':
+            return { kind, reaction: proto.Message.ReactionMessage.decode(plaintext) };
+        case 'poll_vote':
+            return {
+                kind,
+                pollVote: proto.Message.PollVoteMessage.decode(plaintext),
+                selectedOptionNames: null
+            };
+        case 'event_response':
+            return { kind, eventResponse: proto.Message.EventResponseMessage.decode(plaintext) };
+        case 'comment':
+            return { kind, comment: proto.Message.CommentMessage.decode(plaintext) };
+    }
+}
+export async function resolveParentMessageSecret(targetMessageId, messageSecretStore, messageStore) {
+    const cached = await messageSecretStore.get(targetMessageId);
+    if (cached)
+        return cached;
+    const record = await messageStore.getById(targetMessageId);
+    if (!record?.messageBytes)
+        return null;
+    try {
+        const decoded = proto.Message.decode(record.messageBytes);
+        const secret = decoded.messageContextInfo?.messageSecret;
+        if (!secret || secret.byteLength !== WA_MESSAGE_SECRET_BYTES)
+            return null;
+        return { secret, senderJid: record.senderJid ?? '' };
+    }
+    catch {
+        return null;
+    }
+}
+export async function resolvePollOptionNames(selectedOptions, pollCreationMessageId, messageStore) {
+    const record = await messageStore.getById(pollCreationMessageId);
+    if (!record?.messageBytes)
+        return null;
+    let decoded;
+    try {
+        decoded = proto.Message.decode(record.messageBytes);
+    }
+    catch {
+        return null;
+    }
+    const pollMsg = unwrapMessage(decoded);
+    const options = pollMsg.pollCreationMessage?.options ??
+        pollMsg.pollCreationMessageV2?.options ??
+        pollMsg.pollCreationMessageV3?.options ??
+        pollMsg.pollCreationMessageV5?.options;
+    if (!options || options.length === 0)
+        return null;
+    const hashToName = new Map();
+    for (const option of options) {
+        if (!option.optionName)
+            continue;
+        const hash = await sha256(TEXT_ENCODER.encode(option.optionName));
+        hashToName.set(bytesToHex(hash), option.optionName);
+    }
+    const names = [];
+    for (const selected of selectedOptions) {
+        const hex = bytesToHex(selected);
+        const name = hashToName.get(hex);
+        if (!name)
+            return null;
+        names.push(name);
+    }
+    return names;
+}
 function assertAddonIv(iv) {
     const normalized = toBytesView(iv);
     if (normalized.byteLength !== WA_ADDON_ENCRYPTION_NONCE_BYTES) {

package/dist/esm/message/content.js

@@ -1,13 +1,9 @@
 import { proto } from '../proto.js';
 import { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_POLL_META_TYPES, WA_STANZA_MSG_TYPES } from '../protocol/constants.js';
 export function isSendMediaMessage(content) {
-    return (!!content &&
-        typeof content === 'object' &&
-        'type' in content &&
-        'media' in content &&
-        'mimetype' in content);
+    return !!content && typeof content === 'object' && 'type' in content && 'media' in content;
 }
-function unwrapMessage(message) {
+export function unwrapMessage(message) {
     let msg = message;
     for (;;) {
         const inner = msg.ephemeralMessage?.message ??
@@ -70,6 +66,16 @@ export function resolveMessageTypeAttr(message) {
     return WA_STANZA_MSG_TYPES.MEDIA;
 }
 const REVOKED_REACTION_TEXT = '';
+export function needsSecretPersistence(message) {
+    const msg = unwrapMessage(message);
+    return !!(msg.pollCreationMessage ||
+        msg.pollCreationMessageV2 ||
+        msg.pollCreationMessageV3 ||
+        msg.pollCreationMessageV4 ||
+        msg.pollCreationMessageV5 ||
+        msg.pollCreationMessageV6 ||
+        msg.eventMessage);
+}
 export function resolveEditAttr(message, subtype) {
     const msg = unwrapMessage(message);
     if (msg.protocolMessage) {

package/dist/esm/message/icdc.js

@@ -1,13 +1,13 @@
 import { sha256, toRawPubKey } from '../crypto/index.js';
 import { parseSignalAddressFromJid } from '../protocol/jid.js';
 import { concatBytes } from '../util/bytes.js';
-const ICDC_HASH_LENGTH = 8;
+const ICDC_DEFAULT_HASH_LENGTH = 8;
 const ICDC_FRESHNESS_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1000;
 const DEVICE_LIST_METADATA_VERSION = 2;
-const EMPTY_KEY_HASH = new Uint8Array(ICDC_HASH_LENGTH);
-export async function computeDeviceKeyHash(identityKeys) {
+export async function computeDeviceKeyHash(identityKeys, hashLength) {
+    const length = hashLength ?? ICDC_DEFAULT_HASH_LENGTH;
     if (identityKeys.length === 0) {
-        return EMPTY_KEY_HASH;
+        return new Uint8Array(length);
     }
     const rawKeys = new Array(identityKeys.length);
     for (let i = 0; i < identityKeys.length; i += 1) {
@@ -16,9 +16,9 @@ export async function computeDeviceKeyHash(identityKeys) {
     }
     const combined = concatBytes(rawKeys);
     const hash = await sha256(combined);
-    return hash.subarray(0, ICDC_HASH_LENGTH);
+    return hash.subarray(0, length);
 }
-export async function resolveIcdcMeta(deviceJids, signalStore, updatedAtMs, localIdentity) {
+export async function resolveIcdcMeta(deviceJids, identityStore, updatedAtMs, localIdentity, hashLength) {
     if (deviceJids.length === 0) {
         return null;
     }
@@ -26,7 +26,7 @@ export async function resolveIcdcMeta(deviceJids, signalStore, updatedAtMs, loca
     for (let i = 0; i < deviceJids.length; i += 1) {
         addresses[i] = parseSignalAddressFromJid(deviceJids[i]);
     }
-    const remoteKeys = await signalStore.getRemoteIdentities(addresses);
+    const remoteKeys = await identityStore.getRemoteIdentities(addresses);
     const keys = [];
     for (let i = 0; i < addresses.length; i += 1) {
         const key = remoteKeys[i];
@@ -42,7 +42,7 @@ export async function resolveIcdcMeta(deviceJids, signalStore, updatedAtMs, loca
     if (keys.length === 0) {
         return null;
     }
-    const keyHash = await computeDeviceKeyHash(keys);
+    const keyHash = await computeDeviceKeyHash(keys, hashLength);
     const timestamp = updatedAtMs !== undefined && Date.now() - updatedAtMs < ICDC_FRESHNESS_THRESHOLD_MS
         ? Math.floor(updatedAtMs / 1000)
         : undefined;

package/dist/esm/message/incoming.js

@@ -48,14 +48,6 @@ function buildIncomingEventRawNode(node) {
         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) {
@@ -181,7 +173,10 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
         if (shouldEmitIncomingMessage(message)) {
             const chatJid = node.attrs.from;
             options.emitIncomingMessage?.({
-                ...buildBaseIncomingEvent(node),
+                rawNode: buildIncomingEventRawNode(node),
+                stanzaId: node.attrs.id,
+                chatJid,
+                stanzaType: node.attrs.type,
                 timestampSeconds: parseOptionalInt(node.attrs.t),
                 senderJid,
                 encryptionType: encType,
@@ -202,7 +197,10 @@ async function decryptAndProcessEncNode(node, encNode, encType, senderJid, optio
             message: toError(error).message
         });
         options.emitUnhandledStanza?.({
-            ...buildBaseIncomingEvent(node),
+            rawNode: buildIncomingEventRawNode(node),
+            stanzaId: node.attrs.id,
+            chatJid: node.attrs.from,
+            stanzaType: node.attrs.type,
             reason: `message.decrypt_failed.${encType}`
         });
         return { success: false, encType, error };
@@ -233,7 +231,10 @@ export async function handleIncomingMessageAck(node, options) {
                 case 'skmsg': {
                     if (!senderJid || !node.attrs.from || !options.senderKeyManager) {
                         options.emitUnhandledStanza?.({
-                            ...buildBaseIncomingEvent(node),
+                            rawNode: buildIncomingEventRawNode(node),
+                            stanzaId: node.attrs.id,
+                            chatJid: node.attrs.from,
+                            stanzaType: node.attrs.type,
                             reason: 'message.skmsg.missing_group_context'
                         });
                         continue;
@@ -275,7 +276,8 @@ export async function handleIncomingMessageAck(node, options) {
             });
         }
         if (encCount > 0 && !hasSuccessfulDecrypt && firstDecryptFailure) {
-            shouldSendStandardReceipt = !(await sendRetryReceiptForDecryptFailure(node, options, firstDecryptFailure.error, firstDecryptFailure.encType));
+            await sendRetryReceiptForDecryptFailure(node, options, firstDecryptFailure.error, firstDecryptFailure.encType);
+            shouldSendStandardReceipt = false;
         }
     }
     const id = node.attrs.id;

package/dist/esm/message/phash.js

@@ -1,5 +1,4 @@
 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) {
@@ -13,15 +12,36 @@ export async function computePhashV2(participants) {
     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}`;
+    const atIndex = jid.indexOf('@');
+    if (atIndex < 1 || atIndex >= jid.length - 1)
+        return jid;
+    const colonIndex = jid.indexOf(':', 0);
+    const userEnd = colonIndex >= 0 && colonIndex < atIndex ? colonIndex : atIndex;
+    const hasZeroAgent = userEnd >= 2 && jid.charCodeAt(userEnd - 2) === 46 && jid.charCodeAt(userEnd - 1) === 48;
+    const baseUserEnd = hasZeroAgent ? userEnd - 2 : userEnd;
+    const baseUser = jid.slice(0, baseUserEnd);
+    let device = 0;
+    if (colonIndex >= 0 && colonIndex < atIndex) {
+        for (let i = colonIndex + 1; i < atIndex; i += 1) {
+            const digit = jid.charCodeAt(i) - 48;
+            if (digit < 0 || digit > 9) {
+                device = 0;
+                break;
+            }
+            device = device * 10 + digit;
+            if (device > Number.MAX_SAFE_INTEGER) {
+                device = 0;
+                break;
+            }
+        }
+    }
+    const serverStart = atIndex + 1;
+    const serverLen = jid.length - serverStart;
+    const isCUs = serverLen === 4 &&
+        jid.charCodeAt(serverStart) === 99 &&
+        jid.charCodeAt(serverStart + 1) === 46 &&
+        jid.charCodeAt(serverStart + 2) === 117 &&
+        jid.charCodeAt(serverStart + 3) === 115;
+    const normalizedServer = isCUs ? 's.whatsapp.net' : jid.slice(serverStart);
+    return `${baseUser}.0:${device}@${normalizedServer}`;
 }