zapo-js 0.1.1 → 0.2.0

package/dist/esm/message/index.js

@@ -1,2 +1,4 @@
 export { WaMessageClient } from './WaMessageClient.js';
+export * from './addon-crypto.js';
 export * from './types.js';
+export * from './use-case-secret.js';

package/dist/esm/message/phash.js

@@ -5,7 +5,9 @@ export async function computePhashV2(participants) {
     if (participants.length === 0) {
         return '2:';
     }
-    const canonical = participants.map((participant) => toPhashCanonicalWid(participant));
+    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))}`;

package/dist/esm/message/reporting-token.js

@@ -0,0 +1,425 @@
+import { hkdf, hmacSign, importHmacKey } from '../crypto/index.js';
+import { proto } from '../proto.js';
+import { base64ToBytesChecked, concatBytes, EMPTY_BYTES, TEXT_ENCODER, toBytesView } from '../util/bytes.js';
+const WA_REPORTING_TOKEN_BYTES = 16;
+const WA_REPORTING_TOKEN_KEY_BYTES = 32;
+const WA_REPORTING_TOKEN_USE_CASE = 'Report Token';
+const WA_REPORTING_TOKEN_CONFIG_BASE64 = 'CgQIARIACjQIAxIwKgQIAhIAKgQIAxIAKgQICBIAKgQICxIAKhAIERIMKgQIFRIAKgQIFhIAKgQIGRIACioIBBImCAIqBggBEgIIAioGCBASAggCKhIIERIOCAIqBAgVEgAqBAgWEgAKOggFEjYIAioGCAMSAggCKgYIBBICCAIqBggFEgIIAioGCBASAggCKhIIERIOCAIqBAgVEgAqBAgWEgAKIggGEh4qBAgBEgAqEAgREgwqBAgVEgAqBAgWEgAqBAgeEgAKLggHEioqBAgCEgAqBAgHEgAqBAgKEgAqEAgREgwqBAgVEgAqBAgWEgAqBAgUEgAKLggIEioqBAgCEgAqBAgHEgAqBAgJEgAqEAgREgwqBAgVEgAqBAgWEgAqBAgVEgAKNAgJEjAqBAgCEgAqBAgGEgAqBAgHEgAqBAgNEgAqEAgREgwqBAgVEgAqBAgWEgAqBAgUEgAKKAgMEiQIAioGCAESAggCKgYIAhICCAIqCAgOEgQIAiABKgYIDxICCAIKKggSEiYIAioGCAYSAggCKgYIEBICCAIqEggREg4IAioECBUSACoECBYSAAouCBoSKioECAQSACoECAUSACoECAgSACoECA0SACoQCBESDCoECBUSACoECBYSAApCCBwSPggCKgYIARICCAIqBggCEgIIAioGCAQSAggCKgYIBRICCAIqBggGEgIIAioSCAcSDggCKgQIFRIAKgQIFhIACgwIJRIIKgYIARICIAEKUggxEk4IAioGCAISAggCKhYIAxISCAIqBggBEgIIAioGCAISAggCKhIIBRIOCAIqBAgVEgAqBAgWEgAqFggIEhIIAioGCAESAggCKgYIAhICCAIKDAg1EggqBggBEgIgAQoOCDcSCggCKgYIARICIAEKDgg6EgoIAioGCAESAiABCg4IOxIKCAIqBggBEgIgAQpSCDwSTggCKgYIAhICCAIqFggDEhIIAioGCAESAggCKgYIAhICCAIqEggFEg4IAioECBUSACoECBYSACoWCAgSEggCKgYIARICCAIqBggCEgIIAgpSCEASTggCKgYIAhICCAIqFggDEhIIAioGCAESAggCKgYIAhICCAIqEggFEg4IAioECBUSACoECBYSACoWCAgSEggCKgYIARICCAIqBggCEgIIAgo2CEISMggCKgQIAhIAKgQIBhIAKgQIBxIAKgQIDRIAKhAIERIMKgQIFRIAKgQIFhIAKgQIFBIACg4IShIKCAIqBggBEgIgAQoOCFcSCggCKgYIARICIAEKMghYEi4IAioGCAESAggCKg4IAhIKCAIqBggBEgIIAioSCAMSDggCKgQIFRIAKgQIFhIACg4IXBIKCAIqBggBEgIgAQoOCF0SCggCKgYIARICIAEKDgheEgoIAioGCAESAiAB';
+const WA_REPORTING_TOKEN_CONFIG_BYTES = base64ToBytesChecked(WA_REPORTING_TOKEN_CONFIG_BASE64, 'reporting_token.config');
+export const WA_REPORTING_TOKEN_VERSION = 2;
+let reportingTokenConfigSpec = null;
+const reportingTokenConfigCache = new Map();
+export async function buildReportingTokenArtifacts(input) {
+    const stanzaId = input.stanzaId.trim();
+    if (!stanzaId || !isMessageReportingTokenCompatible(input.message)) {
+        return null;
+    }
+    const messageSecret = input.message.messageContextInfo?.messageSecret;
+    if (!messageSecret || toBytesView(messageSecret).byteLength === 0) {
+        return null;
+    }
+    const reportingTokenContent = computeReportingTokenContent(proto.Message.encode(input.message).finish(), input.version ?? WA_REPORTING_TOKEN_VERSION);
+    if (reportingTokenContent.byteLength === 0) {
+        return null;
+    }
+    const secretInfo = TEXT_ENCODER.encode(stanzaId + input.senderUserJid + input.remoteJid + WA_REPORTING_TOKEN_USE_CASE);
+    const reportingTokenKey = await hkdf(toBytesView(messageSecret), null, secretInfo, WA_REPORTING_TOKEN_KEY_BYTES);
+    const hmacKey = await importHmacKey(reportingTokenKey);
+    const reportingToken = (await hmacSign(hmacKey, reportingTokenContent)).subarray(0, WA_REPORTING_TOKEN_BYTES);
+    const version = input.version ?? WA_REPORTING_TOKEN_VERSION;
+    return {
+        node: {
+            tag: 'reporting',
+            attrs: {},
+            content: [
+                {
+                    tag: 'reporting_token',
+                    attrs: {
+                        v: String(version)
+                    },
+                    content: reportingToken
+                }
+            ]
+        },
+        version,
+        reportingToken,
+        reportingTokenContent,
+        reportingTokenKey
+    };
+}
+function isMessageReportingTokenCompatible(message) {
+    return (!message.reactionMessage &&
+        !message.encReactionMessage &&
+        !message.encEventResponseMessage &&
+        !message.pollUpdateMessage);
+}
+function computeReportingTokenContent(messageBytes, version) {
+    const reportingConfig = getReportingTokenConfig(version);
+    const extracted = extractProtobufFieldParts(messageBytes, 0, messageBytes.length, reportingConfig, reportingConfig);
+    if (extracted.totalSize === 0) {
+        return EMPTY_BYTES;
+    }
+    const parts = new Array(extracted.parts.length);
+    for (let index = 0; index < extracted.parts.length; index += 1) {
+        parts[index] = extracted.parts[index].bytes;
+    }
+    return concatBytes(parts);
+}
+function getReportingTokenConfig(version) {
+    const cached = reportingTokenConfigCache.get(version);
+    if (cached) {
+        return cached;
+    }
+    const spec = getReportingTokenConfigSpec();
+    const fields = new Map();
+    for (const [fieldNumber, fieldSpec] of spec.fields) {
+        const selectedField = selectFieldForVersion(version, fieldNumber, fieldSpec);
+        if (selectedField) {
+            fields.set(fieldNumber, selectedField);
+        }
+    }
+    const config = { fields };
+    reportingTokenConfigCache.set(version, config);
+    return config;
+}
+function getReportingTokenConfigSpec() {
+    if (reportingTokenConfigSpec) {
+        return reportingTokenConfigSpec;
+    }
+    reportingTokenConfigSpec = parseReportingTokenConfigSpec(WA_REPORTING_TOKEN_CONFIG_BYTES);
+    return reportingTokenConfigSpec;
+}
+function parseReportingTokenConfigSpec(bytes) {
+    let cursor = 0;
+    const fields = new Map();
+    while (cursor < bytes.length) {
+        const tag = readVarint(bytes, cursor, bytes.length);
+        cursor = tag.next;
+        const fieldNumber = Math.floor(tag.value / 8);
+        const wireType = tag.value & 0x07;
+        if (fieldNumber === 1 && wireType === 2) {
+            const lengthInfo = readVarint(bytes, cursor, bytes.length);
+            const entryStart = lengthInfo.next;
+            const entryEnd = entryStart + lengthInfo.value;
+            if (entryEnd > bytes.length) {
+                throw new Error('invalid reporting token config map entry length');
+            }
+            const parsedEntry = parseReportingTokenConfigMapEntry(bytes, entryStart, entryEnd);
+            if (parsedEntry) {
+                fields.set(parsedEntry.key, parsedEntry.value);
+            }
+            cursor = entryEnd;
+            continue;
+        }
+        cursor = skipField(bytes, cursor, bytes.length, wireType);
+    }
+    return { fields };
+}
+function parseReportingTokenConfigMapEntry(bytes, start, end) {
+    let cursor = start;
+    let key = null;
+    let value = null;
+    while (cursor < end) {
+        const tag = readVarint(bytes, cursor, end);
+        cursor = tag.next;
+        const fieldNumber = Math.floor(tag.value / 8);
+        const wireType = tag.value & 0x07;
+        if (fieldNumber === 1 && wireType === 0) {
+            const keyVarint = readVarint(bytes, cursor, end);
+            key = keyVarint.value;
+            cursor = keyVarint.next;
+            continue;
+        }
+        if (fieldNumber === 2 && wireType === 2) {
+            const valueLength = readVarint(bytes, cursor, end);
+            const valueStart = valueLength.next;
+            const valueEnd = valueStart + valueLength.value;
+            if (valueEnd > end) {
+                throw new Error('invalid reporting token config field value length');
+            }
+            value = parseReportingTokenFieldSpec(bytes, valueStart, valueEnd);
+            cursor = valueEnd;
+            continue;
+        }
+        cursor = skipField(bytes, cursor, end, wireType);
+    }
+    if (key === null || value === null) {
+        return null;
+    }
+    return { key, value };
+}
+function parseReportingTokenFieldSpec(bytes, start, end) {
+    let cursor = start;
+    let minVersion = 1;
+    let maxVersion = null;
+    let isMessage = false;
+    const subfields = new Map();
+    while (cursor < end) {
+        const tag = readVarint(bytes, cursor, end);
+        cursor = tag.next;
+        const fieldNumber = Math.floor(tag.value / 8);
+        const wireType = tag.value & 0x07;
+        if (fieldNumber === 1 && wireType === 0) {
+            const value = readVarint(bytes, cursor, end);
+            minVersion = value.value;
+            cursor = value.next;
+            continue;
+        }
+        if (fieldNumber === 2 && wireType === 0) {
+            const value = readVarint(bytes, cursor, end);
+            maxVersion = value.value;
+            cursor = value.next;
+            continue;
+        }
+        if (fieldNumber === 4 && wireType === 0) {
+            const value = readVarint(bytes, cursor, end);
+            isMessage = value.value !== 0;
+            cursor = value.next;
+            continue;
+        }
+        if (fieldNumber === 5 && wireType === 2) {
+            const lengthInfo = readVarint(bytes, cursor, end);
+            const entryStart = lengthInfo.next;
+            const entryEnd = entryStart + lengthInfo.value;
+            if (entryEnd > end) {
+                throw new Error('invalid reporting token subfield map entry length');
+            }
+            const parsedEntry = parseReportingTokenConfigMapEntry(bytes, entryStart, entryEnd);
+            if (parsedEntry) {
+                subfields.set(parsedEntry.key, parsedEntry.value);
+            }
+            cursor = entryEnd;
+            continue;
+        }
+        cursor = skipField(bytes, cursor, end, wireType);
+    }
+    return {
+        minVersion,
+        maxVersion,
+        isMessage,
+        subfields: subfields.size > 0 ? subfields : null
+    };
+}
+function selectFieldForVersion(version, fieldNumber, fieldSpec) {
+    if (version < fieldSpec.minVersion) {
+        return null;
+    }
+    if (fieldSpec.maxVersion !== null && version > fieldSpec.maxVersion) {
+        return null;
+    }
+    if (!fieldSpec.subfields) {
+        return {
+            fieldNumber,
+            isMessage: fieldSpec.isMessage,
+            subfields: null
+        };
+    }
+    const selectedSubfields = new Map();
+    for (const [subFieldNumber, subFieldSpec] of fieldSpec.subfields) {
+        const selectedField = selectFieldForVersion(version, subFieldNumber, subFieldSpec);
+        if (selectedField) {
+            selectedSubfields.set(subFieldNumber, selectedField);
+        }
+    }
+    return {
+        fieldNumber,
+        isMessage: fieldSpec.isMessage,
+        subfields: {
+            fields: selectedSubfields
+        }
+    };
+}
+function extractProtobufFieldParts(bytes, start, end, config, rootConfig) {
+    const parts = [];
+    let totalSize = 0;
+    let cursor = start;
+    while (cursor < end) {
+        const parsedField = parseProtobufField(bytes, cursor, end);
+        cursor = parsedField.next;
+        const configuredField = config.fields.get(parsedField.fieldNumber);
+        if (!configuredField) {
+            continue;
+        }
+        if (!configuredField.isMessage &&
+            (!configuredField.subfields || configuredField.subfields.fields.size === 0)) {
+            const fieldBytes = bytes.subarray(parsedField.start, parsedField.next);
+            parts.push({
+                fieldNumber: parsedField.fieldNumber,
+                bytes: fieldBytes
+            });
+            totalSize += fieldBytes.length;
+            continue;
+        }
+        if (parsedField.wireType !== 2) {
+            continue;
+        }
+        const nestedConfig = configuredField.isMessage ? rootConfig : configuredField.subfields;
+        if (!nestedConfig) {
+            continue;
+        }
+        const nestedFields = extractProtobufFieldParts(bytes, parsedField.valueStart, parsedField.valueEnd, nestedConfig, rootConfig);
+        if (nestedFields.parts.length === 0 || nestedFields.totalSize === 0) {
+            continue;
+        }
+        const tagBytes = encodeVarint(parsedField.tag);
+        const nestedLengthBytes = encodeVarint(nestedFields.totalSize);
+        const fieldBytes = new Uint8Array(tagBytes.length + nestedLengthBytes.length + nestedFields.totalSize);
+        fieldBytes.set(tagBytes, 0);
+        fieldBytes.set(nestedLengthBytes, tagBytes.length);
+        let nestedOffset = tagBytes.length + nestedLengthBytes.length;
+        for (const nestedPart of nestedFields.parts) {
+            fieldBytes.set(nestedPart.bytes, nestedOffset);
+            nestedOffset += nestedPart.bytes.length;
+        }
+        parts.push({
+            fieldNumber: parsedField.fieldNumber,
+            bytes: fieldBytes
+        });
+        totalSize += fieldBytes.length;
+    }
+    parts.sort((left, right) => left.fieldNumber - right.fieldNumber);
+    return {
+        parts,
+        totalSize
+    };
+}
+function parseProtobufField(bytes, start, end) {
+    const tag = readVarint(bytes, start, end);
+    const tagValue = tag.value;
+    if (tagValue <= 0 || tagValue > 4294967295) {
+        throw new Error(`protobuf field tag out of bounds: ${tagValue}`);
+    }
+    const fieldNumber = Math.floor(tagValue / 8);
+    if (fieldNumber < 1) {
+        throw new Error(`invalid protobuf field number: ${fieldNumber}`);
+    }
+    const wireType = tagValue & 0x07;
+    if (wireType === 0) {
+        const value = readVarint(bytes, tag.next, end);
+        return {
+            tag: tagValue,
+            fieldNumber,
+            wireType,
+            start,
+            next: value.next,
+            valueStart: value.next,
+            valueEnd: value.next
+        };
+    }
+    if (wireType === 1) {
+        const next = tag.next + 8;
+        if (next > end) {
+            throw new Error('invalid protobuf fixed64 field length');
+        }
+        return {
+            tag: tagValue,
+            fieldNumber,
+            wireType,
+            start,
+            next,
+            valueStart: next,
+            valueEnd: next
+        };
+    }
+    if (wireType === 2) {
+        const valueLength = readVarint(bytes, tag.next, end);
+        const valueStart = valueLength.next;
+        const valueEnd = valueStart + valueLength.value;
+        if (valueEnd > end) {
+            throw new Error('invalid protobuf length-delimited field length');
+        }
+        return {
+            tag: tagValue,
+            fieldNumber,
+            wireType,
+            start,
+            next: valueEnd,
+            valueStart,
+            valueEnd
+        };
+    }
+    if (wireType === 5) {
+        const next = tag.next + 4;
+        if (next > end) {
+            throw new Error('invalid protobuf fixed32 field length');
+        }
+        return {
+            tag: tagValue,
+            fieldNumber,
+            wireType,
+            start,
+            next,
+            valueStart: next,
+            valueEnd: next
+        };
+    }
+    throw new Error(`unsupported protobuf wire type: ${wireType}`);
+}
+function readVarint(bytes, start, end) {
+    let cursor = start;
+    let value = 0;
+    let factor = 1;
+    while (cursor < end) {
+        const byte = bytes[cursor];
+        value += (byte & 0x7f) * factor;
+        if (!Number.isSafeInteger(value)) {
+            throw new Error('varint exceeds safe integer range');
+        }
+        cursor += 1;
+        if ((byte & 0x80) === 0) {
+            return {
+                value,
+                next: cursor
+            };
+        }
+        factor *= 128;
+        if (factor > 2 ** 56) {
+            throw new Error('varint exceeds supported range');
+        }
+    }
+    throw new Error('unexpected end of buffer while reading varint');
+}
+function skipField(bytes, start, end, wireType) {
+    if (wireType === 0) {
+        return readVarint(bytes, start, end).next;
+    }
+    if (wireType === 1) {
+        const next = start + 8;
+        if (next > end) {
+            throw new Error('invalid fixed64 field size while skipping');
+        }
+        return next;
+    }
+    if (wireType === 2) {
+        const lengthInfo = readVarint(bytes, start, end);
+        const next = lengthInfo.next + lengthInfo.value;
+        if (next > end) {
+            throw new Error('invalid length-delimited field size while skipping');
+        }
+        return next;
+    }
+    if (wireType === 5) {
+        const next = start + 4;
+        if (next > end) {
+            throw new Error('invalid fixed32 field size while skipping');
+        }
+        return next;
+    }
+    throw new Error(`unsupported wire type while skipping field: ${wireType}`);
+}
+function encodeVarint(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`invalid varint value: ${value}`);
+    }
+    const bytes = new Uint8Array(10);
+    let length = 0;
+    let current = value;
+    while (current >= 128) {
+        bytes[length] = (current % 128) + 128;
+        length += 1;
+        current = Math.floor(current / 128);
+    }
+    bytes[length] = current;
+    length += 1;
+    return bytes.subarray(0, length);
+}

package/dist/esm/message/use-case-secret.js

@@ -0,0 +1,49 @@
+import { hkdf, randomBytesAsync } from '../crypto/index.js';
+import { TEXT_ENCODER, toBytesView } from '../util/bytes.js';
+export const WA_MESSAGE_SECRET_BYTES = 32;
+export const WA_USE_CASE_SECRET_MODIFICATION_TYPES = Object.freeze({
+    POLL_VOTE: 'Poll Vote',
+    ENC_REACTION: 'Enc Reaction',
+    ENC_COMMENT: 'Enc Comment',
+    REPORT_TOKEN: 'Report Token',
+    EVENT_RESPONSE: 'Event Response',
+    EVENT_EDIT_ENCRYPTED: 'Event Edit',
+    MESSAGE_EDIT: 'Message Edit'
+});
+export function assertMessageSecret(messageSecret, context = 'message secret') {
+    const bytes = toBytesView(messageSecret);
+    if (bytes.byteLength !== WA_MESSAGE_SECRET_BYTES) {
+        throw new Error(`${context} must be ${WA_MESSAGE_SECRET_BYTES} bytes (got ${bytes.byteLength})`);
+    }
+    return bytes;
+}
+export async function ensureMessageSecret(message) {
+    const messageSecret = message.messageContextInfo?.messageSecret;
+    if (messageSecret && toBytesView(messageSecret).byteLength > 0) {
+        return message;
+    }
+    const generatedMessageSecret = await randomBytesAsync(WA_MESSAGE_SECRET_BYTES);
+    return {
+        ...message,
+        messageContextInfo: {
+            ...(message.messageContextInfo ?? {}),
+            messageSecret: generatedMessageSecret
+        }
+    };
+}
+export async function createUseCaseSecret(input) {
+    if (!input.stanzaId.trim()) {
+        throw new Error('stanza id must be a non-empty string');
+    }
+    if (!input.parentMsgOriginalSender.trim()) {
+        throw new Error('parent message original sender must be a non-empty string');
+    }
+    if (!input.modificationSender.trim()) {
+        throw new Error('modification sender must be a non-empty string');
+    }
+    const secretInfo = TEXT_ENCODER.encode(input.stanzaId +
+        input.parentMsgOriginalSender +
+        input.modificationSender +
+        input.modificationType);
+    return hkdf(assertMessageSecret(input.messageSecret), null, secretInfo, WA_MESSAGE_SECRET_BYTES);
+}

package/dist/esm/protocol/appstate.js

@@ -32,3 +32,30 @@ export const WA_APP_STATE_KDF_INFO = Object.freeze({
     MUTATION_KEYS: 'WhatsApp Mutation Keys',
     PATCH_INTEGRITY: 'WhatsApp Patch Integrity'
 });
+export const WA_APP_STATE_CHAT_MUTATION_SPECS = Object.freeze({
+    STAR: { collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH, action: 'star', version: 2 },
+    MUTE: { collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH, action: 'mute', version: 2 },
+    PIN: { collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW, action: 'pin_v1', version: 5 },
+    ARCHIVE: { collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW, action: 'archive', version: 3 },
+    DELETE_MESSAGE_FOR_ME: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
+        action: 'deleteMessageForMe',
+        version: 3
+    },
+    MARK_CHAT_AS_READ: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
+        action: 'markChatAsRead',
+        version: 3
+    },
+    CLEAR_CHAT: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
+        action: 'clearChat',
+        version: 6
+    },
+    DELETE_CHAT: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
+        action: 'deleteChat',
+        version: 6
+    },
+    LOCK_CHAT: { collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW, action: 'lock', version: 7 }
+});

package/dist/esm/protocol/browser.js

@@ -19,23 +19,15 @@ export const WA_COMPANION_PLATFORM_IDS = Object.freeze({
     UWP: '8',
     OTHER_WEB_CLIENT: '9'
 });
+const BROWSER_TO_PLATFORM_ID = {
+    [WA_BROWSERS.CHROME]: WA_COMPANION_PLATFORM_IDS.CHROME,
+    [WA_BROWSERS.FIREFOX]: WA_COMPANION_PLATFORM_IDS.FIREFOX,
+    [WA_BROWSERS.IE]: WA_COMPANION_PLATFORM_IDS.IE,
+    [WA_BROWSERS.OPERA]: WA_COMPANION_PLATFORM_IDS.OPERA,
+    [WA_BROWSERS.SAFARI]: WA_COMPANION_PLATFORM_IDS.SAFARI,
+    [WA_BROWSERS.EDGE]: WA_COMPANION_PLATFORM_IDS.EDGE
+};
 export function getWaCompanionPlatformId(browser) {
-    const normalized = browser.trim().toLowerCase();
-    switch (normalized) {
-        case WA_BROWSERS.CHROME:
-            return WA_COMPANION_PLATFORM_IDS.CHROME;
-        case WA_BROWSERS.FIREFOX:
-            return WA_COMPANION_PLATFORM_IDS.FIREFOX;
-        case WA_BROWSERS.IE:
-            return WA_COMPANION_PLATFORM_IDS.IE;
-        case WA_BROWSERS.OPERA:
-            return WA_COMPANION_PLATFORM_IDS.OPERA;
-        case WA_BROWSERS.SAFARI:
-            return WA_COMPANION_PLATFORM_IDS.SAFARI;
-        case WA_BROWSERS.EDGE:
-            return WA_COMPANION_PLATFORM_IDS.EDGE;
-        case WA_BROWSERS.CHROMIUM:
-        default:
-            return WA_COMPANION_PLATFORM_IDS.OTHER_WEB_CLIENT;
-    }
+    return (BROWSER_TO_PLATFORM_ID[browser.trim().toLowerCase()] ??
+        WA_COMPANION_PLATFORM_IDS.OTHER_WEB_CLIENT);
 }

package/dist/esm/protocol/constants.js

@@ -1,11 +1,14 @@
 export { getWaCompanionPlatformId, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS } from './browser.js';
 export { WA_SIGNALING, WA_PAIRING_KDF_INFO } from './auth.js';
-export { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream.js';
+export { WA_CONNECTION_REASONS, WA_DISCONNECT_REASONS, WA_FAILURE_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream.js';
 export { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from './nodes.js';
-export { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from './message.js';
-export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate.js';
+export { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_POLL_META_TYPES, WA_RETRYABLE_ACK_CODES, WA_STANZA_MSG_TYPES } from './message.js';
+export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_CHAT_MUTATION_SPECS, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate.js';
 export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media.js';
 export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty.js';
 export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification.js';
+export { WA_PRIVACY_TOKEN_NOTIFICATION_TYPE, WA_PRIVACY_TOKEN_TAGS, WA_PRIVACY_TOKEN_TYPES, WA_TC_TOKEN_DEFAULTS } from './privacy-token.js';
+export { WA_PRIVACY_CATEGORIES, WA_PRIVACY_CATEGORY_TO_SETTING, WA_PRIVACY_DISALLOWED_LIST_CATEGORIES, WA_PRIVACY_SETTING_TO_CATEGORY, WA_PRIVACY_TAGS, WA_PRIVACY_VALUES } from './privacy.js';
 export { WA_DEFAULTS } from './defaults.js';
 export { WA_GROUP_PARTICIPANT_TYPES } from './group.js';
+export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync.js';

package/dist/esm/protocol/defaults.js

@@ -3,6 +3,12 @@ export const WA_DEFAULTS = Object.freeze({
     HOST_DOMAIN: 's.whatsapp.net',
     GROUP_SERVER: 'g.us',
     BROADCAST_SERVER: 'broadcast',
+    LID_SERVER: 'lid',
+    HOSTED_SERVER: 'hosted',
+    HOSTED_LID_SERVER: 'hosted.lid',
+    HOSTED_DEVICE_ID: 99,
+    MSGR_SERVER: 'msgr',
+    INTEROP_SERVER: 'interop',
     DEVICE_BROWSER: WA_BROWSERS.FIREFOX,
     DEVICE_PLATFORM: getWaCompanionPlatformId(WA_BROWSERS.FIREFOX),
     CHAT_SOCKET_URLS: ['wss://web.whatsapp.com/ws/chat', 'wss://web.whatsapp.com:5222/ws/chat'],

package/dist/esm/protocol/index.js

@@ -1,11 +1,2 @@
-export { getWaCompanionPlatformId, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS } from './browser.js';
-export { WA_SIGNALING, WA_PAIRING_KDF_INFO } from './auth.js';
-export { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream.js';
-export { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from './nodes.js';
-export { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from './message.js';
-export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate.js';
-export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media.js';
-export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty.js';
-export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification.js';
-export { WA_DEFAULTS } from './defaults.js';
-export { getLoginIdentity, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid } from './jid.js';
+export * from './constants.js';
+export { buildDeviceJid, canonicalizeSignalJid, canonicalizeSignalServer, getLoginIdentity, isHostedDeviceId, isHostedDeviceJid, isHostedServer, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, signalAddressKey, toUserJid } from './jid.js';