zapo-js 0.2.0 → 0.3.0

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

@@ -1,6 +1,6 @@
 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';
+import { base64ToBytesChecked, concatBytes, EMPTY_BYTES, TEXT_ENCODER } 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';
@@ -15,7 +15,7 @@ export async function buildReportingTokenArtifacts(input) {
         return null;
     }
     const messageSecret = input.message.messageContextInfo?.messageSecret;
-    if (!messageSecret || toBytesView(messageSecret).byteLength === 0) {
+    if (!messageSecret || messageSecret.byteLength === 0) {
         return null;
     }
     const reportingTokenContent = computeReportingTokenContent(proto.Message.encode(input.message).finish(), input.version ?? WA_REPORTING_TOKEN_VERSION);
@@ -23,7 +23,7 @@ export async function buildReportingTokenArtifacts(input) {
         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 reportingTokenKey = await hkdf(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;

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

@@ -19,7 +19,7 @@ export function assertMessageSecret(messageSecret, context = 'message secret') {
 }
 export async function ensureMessageSecret(message) {
     const messageSecret = message.messageContextInfo?.messageSecret;
-    if (messageSecret && toBytesView(messageSecret).byteLength > 0) {
+    if (messageSecret && messageSecret.byteLength > 0) {
         return message;
     }
     const generatedMessageSecret = await randomBytesAsync(WA_MESSAGE_SECRET_BYTES);

package/dist/esm/protocol/abprops.js

@@ -0,0 +1,159 @@
+export const WA_ABPROPS_PROTOCOL_VERSION = '1';
+export const WA_ABPROPS_REFRESH_BOUNDS = Object.freeze({
+    MIN_S: 600,
+    MAX_S: 604800,
+    DEFAULT_S: 86400
+});
+function prop(configCode, type, defaultValue) {
+    return { configCode, type, defaultValue };
+}
+export const AB_PROP_CONFIGS = Object.freeze({
+    // --- app state sync (syncd) ---
+    syncd_key_max_use_days: prop(5498, 'int', 90),
+    syncd_wait_for_key_timeout_days: prop(5499, 'int', 30),
+    syncd_sentinel_timeout_seconds: prop(5500, 'int', 60),
+    syncd_inline_mutations_max_count: prop(5501, 'int', 1000),
+    syncd_patch_protobuf_max_size: prop(5502, 'int', 1048576),
+    syncd_additional_mutations_count: prop(2777, 'int', 1),
+    syncd_periodic_sync_days: prop(1400, 'int', 0),
+    syncd_mutation_and_bundle_logging: prop(11821, 'string', '{"allowlist": []}'),
+    wa_web_enable_syncd_key_persistence_only_after_server_ack: prop(27069, 'bool', false),
+    web_request_missing_keys_for_removes: prop(11695, 'bool', false),
+    web_syncd_max_mutations_to_process_during_resume: prop(15808, 'int', 10000),
+    web_syncd_fatal_fields_from_L1104589PRV2: prop(1808, 'bool', false),
+    web_enable_improved_bulk_merge: prop(19854, 'bool', false),
+    snapshot_recovery_max_mutations_count_allowed: prop(18786, 'int', 2000),
+    md_syncd_logging_spec_enabled: prop(14499, 'bool', false),
+    kmp_syncd_engine_crypto_enabled: prop(15909, 'bool', false),
+    enable_syncd_debug_data_in_patch: prop(6614, 'bool', false),
+    enable_mention_everyone_syncd_sender: prop(24244, 'bool', false),
+    username_contact_syncd_support_enable: prop(17614, 'bool', false),
+    // --- message sending / encryption ---
+    after_read_sending_enabled: prop(7293, 'bool', false),
+    after_read_fallback_duration: prop(7294, 'int', 86400),
+    after_read_receiver_enabled: prop(7295, 'bool', false),
+    privacy_token_sending_on_all_1_on_1_messages: prop(9281, 'bool', false),
+    flows_termination_message_v2_sending_enabled: prop(9157, 'bool', false),
+    dm_initiator_trigger_groups: prop(7141, 'bool', false),
+    placeholder_message_resend_maximum_days_limit: prop(3639, 'int', 14),
+    message_edit_to_message_secret_sender_enabled: prop(16057, 'bool', false),
+    message_edit_to_message_secret_receiver_enabled: prop(17811, 'bool', false),
+    top_level_message_secret_check: prop(23796, 'bool', false),
+    parse_encrypted_dsm_msg_fix: prop(26772, 'bool', false),
+    rt_sender_dual_encrypted_msg_enabled: prop(12623, 'bool', true),
+    rt_receiver_dual_encrypted_msg_enabled: prop(15258, 'bool', true),
+    lid_one_to_one_migration_event_response_force_pn_jid: prop(15791, 'bool', false),
+    web_anr_async_msg_send_handler: prop(27249, 'bool', false),
+    message_keys_async_chunk_size: prop(22815, 'int', 50),
+    synced_message_keys_processing_type: prop(22825, 'string', 'control'),
+    limit_sharing_protocol_message_receiver_enabled: prop(15129, 'bool', false),
+    web_pnless_stanzas: prop(26211, 'bool', false),
+    // --- NCT tokens ---
+    wa_nct_token_send_enabled: prop(24941, 'bool', false),
+    wa_nct_token_syncd_enabled: prop(25253, 'bool', false),
+    wa_nct_token_history_sync_enabled: prop(25189, 'bool', false),
+    // --- group ---
+    community_announcement_group_size_limit: prop(2774, 'int', 5000),
+    group_size_limit: prop(1304, 'int', 257),
+    group_max_subject: prop(3597, 'int', 100),
+    group_description_length: prop(14778, 'int', 2048),
+    anyone_can_link_to_groups: prop(3978, 'bool', false),
+    group_call_max_participants: prop(4190, 'int', 32),
+    group_history_receive: prop(15311, 'bool', false),
+    group_history_send: prop(15313, 'bool', false),
+    group_history_settings: prop(21261, 'bool', false),
+    group_history_settings_query: prop(22230, 'bool', false),
+    group_history_message_count_limit: prop(18405, 'int', 100),
+    group_history_message_count_receiver_upper_limit: prop(19811, 'int', 100),
+    group_history_messages_time_limit_receiver_enforcement_secs: prop(21313, 'int', 1209600),
+    group_history_bundle_time_limit_receiver_enforcement_secs: prop(25910, 'int', 1209600),
+    group_history_notice_receive: prop(15722, 'bool', false),
+    group_history_out_of_window_pin_sender: prop(26037, 'bool', false),
+    group_history_out_of_window_pins_receiver: prop(26039, 'bool', false),
+    group_history_reporting: prop(22329, 'bool', true),
+    group_create_add_using_lid_jids: prop(16192, 'bool', false),
+    group_member_updates_hide_in_thread_enabled: prop(24584, 'bool', false),
+    group_status_receiver_enabled: prop(13956, 'bool', false),
+    web_send_invisible_msg_max_group_size: prop(13289, 'int', 256),
+    web_send_invisible_msg_min_group_size: prop(13290, 'int', 50),
+    admin_only_mention_everyone_group_size: prop(18500, 'int', 0),
+    // --- history sync ---
+    web_abprop_drop_full_history_sync: prop(13034, 'bool', false),
+    wa_web_history_sync_dynamic_throttling: prop(19110, 'bool', true),
+    web_e2e_backfill_expire_time: prop(3234, 'int', 5),
+    history_sync_on_demand: prop(3337, 'bool', false),
+    history_sync_on_demand_message_count: prop(3811, 'int', 50),
+    history_sync_on_demand_failure_limit: prop(4364, 'int', 10),
+    history_sync_on_demand_cooldown_sec: prop(4365, 'int', 7200),
+    history_sync_on_demand_complete_companion: prop(21024, 'bool', false),
+    history_sync_on_demand_with_android_beta: prop(4135, 'bool', false),
+    web_anr_throttle_history_sync_db_writes: prop(19298, 'bool', false),
+    web_force_lid_chats_in_history: prop(24343, 'bool', false),
+    web_history_sync_allow_duplicate_in_bulk_error: prop(10842, 'bool', false),
+    // --- media ---
+    default_media_limit_mb: prop(3660, 'int', 16),
+    web_image_max_edge: prop(10371, 'int', 1600),
+    web_image_max_hd_edge: prop(3204, 'int', 2560),
+    web_channel_video_server_transcode_upload: prop(19920, 'bool', false),
+    web_deprecate_mms4_hash_based_download: prop(3152, 'bool', false),
+    kaleidoscope_thumbnail_validation: prop(18114, 'bool', false),
+    web_use_kaleidoscope_media_check_enabled: prop(20375, 'bool', false),
+    low_cache_hit_rate_media_types: prop(4836, 'string', 'ptt,audio,document,ppic'),
+    web_anr_async_media_decryption_enabled: prop(23200, 'bool', false),
+    web_anr_media_chunk_enc_delay_enabled: prop(22931, 'bool', false),
+    web_media_compute_in_worker_enabled: prop(25641, 'bool', false),
+    // --- device management / auth ---
+    adv_accept_hosted_devices: prop(6939, 'bool', false),
+    num_days_key_index_list_expiration: prop(730, 'int', 35),
+    num_days_before_device_expiry_check: prop(731, 'int', 7),
+    web_adv_logout_on_self_device_list_expired: prop(11011, 'bool', false),
+    md_icdc_hash_length: prop(310, 'int', 10),
+    noise_pq_mode: prop(20161, 'int', 0),
+    // --- trusted contacts / privacy tokens ---
+    tctoken_duration: prop(865, 'int', 604800),
+    tctoken_num_buckets: prop(909, 'int', 4),
+    tctoken_num_buckets_sender: prop(997, 'int', 4),
+    tctoken_duration_sender: prop(996, 'int', 604800),
+    // --- connection / offline ---
+    heartbeat_interval_s: prop(1430, 'int', 10),
+    web_offline_message_processor_timeout_seconds: prop(12834, 'int', 15),
+    web_offline_resume_wait_for_ping_response_enabled: prop(14567, 'bool', false),
+    web_offline_resume_wait_for_ping_timeout_seconds: prop(14568, 'int', 5),
+    web_comms_socket_reconnect_enabled: prop(7854, 'bool', false),
+    // --- receipts ---
+    web_resume_optimized_read_receipt_send_interval: prop(13978, 'int', 3000),
+    web_reaction_inactive_receipt: prop(25954, 'bool', false),
+    lid_status_non_soaked_client_support_enabled: prop(19696, 'bool', true),
+    // --- signal protocol ---
+    s567418_mitigation_enabled: prop(22029, 'bool', true),
+    web_signal_future_messages_max: prop(12509, 'int', 20000),
+    // --- polls ---
+    poll_add_option_enabled: prop(24517, 'bool', false),
+    poll_add_option_receiving_enabled: prop(25758, 'int', 0),
+    poll_creator_edit_enabled: prop(24887, 'bool', false),
+    poll_creator_edit_receiving_version: prop(24886, 'int', 0),
+    poll_end_time_enabled: prop(24405, 'bool', false),
+    poll_end_time_receiving_enabled: prop(24884, 'bool', false),
+    poll_hide_voters_enabled: prop(24518, 'bool', false),
+    poll_hide_voters_receiving_enabled: prop(24885, 'int', 0),
+    // --- status / ephemeral ---
+    text_status_ttl_seconds_allowlist: prop(6153, 'string', '1800,3600,7200,14400,28800,86400'),
+    // --- username ---
+    username_enabled_on_companion: prop(23817, 'bool', false),
+    username_max_length: prop(20459, 'int', 35),
+    username_min_length: prop(20494, 'int', 3),
+    // --- message capping ---
+    wa_individual_new_chat_msg_capping_enabled: prop(20865, 'bool', false),
+    wa_individual_new_chat_msg_capping_limit: prop(17845, 'int', 0),
+    wa_individual_new_chat_msg_capping_fetch_ttl_seconds: prop(20649, 'int', 3600),
+    // --- calling ---
+    enable_web_calling: prop(15461, 'bool', false),
+    calling_lid_version: prop(3358, 'int', 0)
+});
+const CONFIG_CODE_TO_NAME = new Map();
+for (const [name, entry] of Object.entries(AB_PROP_CONFIGS)) {
+    CONFIG_CODE_TO_NAME.set(entry.configCode, name);
+}
+export function resolveAbPropNameByCode(configCode) {
+    return CONFIG_CODE_TO_NAME.get(configCode);
+}

package/dist/esm/protocol/browser.js

@@ -7,6 +7,8 @@ export const WA_BROWSERS = Object.freeze({
     OPERA: 'opera',
     EDGE: 'edge'
 });
+// Distinct from proto.DeviceProps.PlatformType: these are the string IDs sent
+// as companionPlatformId in the pairing link_code XML stanza, not the proto enum.
 export const WA_COMPANION_PLATFORM_IDS = Object.freeze({
     UNKNOWN: '0',
     CHROME: '1',
@@ -27,7 +29,19 @@ const BROWSER_TO_PLATFORM_ID = {
     [WA_BROWSERS.SAFARI]: WA_COMPANION_PLATFORM_IDS.SAFARI,
     [WA_BROWSERS.EDGE]: WA_COMPANION_PLATFORM_IDS.EDGE
 };
+const BROWSER_TO_DISPLAY_NAME = {
+    [WA_BROWSERS.CHROME]: 'Chrome',
+    [WA_BROWSERS.CHROMIUM]: 'Chromium',
+    [WA_BROWSERS.FIREFOX]: 'Firefox',
+    [WA_BROWSERS.IE]: 'IE',
+    [WA_BROWSERS.OPERA]: 'Opera',
+    [WA_BROWSERS.SAFARI]: 'Safari',
+    [WA_BROWSERS.EDGE]: 'Edge'
+};
 export function getWaCompanionPlatformId(browser) {
     return (BROWSER_TO_PLATFORM_ID[browser.trim().toLowerCase()] ??
         WA_COMPANION_PLATFORM_IDS.OTHER_WEB_CLIENT);
 }
+export function getWaBrowserDisplayName(browser) {
+    return BROWSER_TO_DISPLAY_NAME[browser.trim().toLowerCase()] ?? browser;
+}

package/dist/esm/protocol/constants.js

@@ -6,9 +6,11 @@ export { WA_EDIT_ATTRS, WA_ENC_MEDIA_TYPES, WA_EVENT_META_TYPES, WA_MESSAGE_TAGS
 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_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES, WA_REGISTRATION_NOTIFICATION_TAGS } 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_EMAIL_CONTEXTS, WA_EMAIL_ERROR_CODES, WA_EMAIL_LIMITS, WA_EMAIL_TAGS, WA_EMAIL_XMLNS } from './email.js';
+export { AB_PROP_CONFIGS, resolveAbPropNameByCode, WA_ABPROPS_PROTOCOL_VERSION, WA_ABPROPS_REFRESH_BOUNDS } from './abprops.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/email.js

@@ -0,0 +1,30 @@
+export const WA_EMAIL_XMLNS = 'urn:xmpp:whatsapp:account';
+export const WA_EMAIL_TAGS = Object.freeze({
+    EMAIL: 'email',
+    EMAIL_ADDRESS: 'email_address',
+    VERIFY_EMAIL: 'verify_email',
+    CONFIRM_EMAIL: 'confirm_email',
+    CONTEXT: 'context',
+    CODE: 'code',
+    LG: 'lg',
+    LC: 'lc',
+    AUTO_VERIFY: 'auto_verify',
+    CONFIRMED: 'confirmed'
+});
+export const WA_EMAIL_CONTEXTS = Object.freeze({
+    ONBOARDING: 'onboarding',
+    SETTINGS: 'settings'
+});
+export const WA_EMAIL_LIMITS = Object.freeze({
+    EMAIL_MAX_LENGTH: 320,
+    CODE_LENGTH: 6,
+    LOCALE_MIN_LENGTH: 2,
+    LOCALE_MAX_LENGTH: 3
+});
+export const WA_EMAIL_ERROR_CODES = Object.freeze({
+    FORBIDDEN: 403,
+    LOCKOUT: 534,
+    CODE_EXPIRED: 535,
+    CODE_INCORRECT: 536,
+    TOO_MANY_RETRIES: 537
+});

package/dist/esm/protocol/jid.js

@@ -58,7 +58,13 @@ export function normalizeRecipientJid(to) {
 }
 function isJidType(jid, type) {
     const atIndex = jid.length - type.length - 1;
-    return atIndex >= 1 && jid.charCodeAt(atIndex) === 64 && jid.endsWith(type);
+    return (atIndex >= 1 &&
+        jid.charCodeAt(atIndex) === 64 &&
+        jid.indexOf('@') === atIndex &&
+        jid.endsWith(type));
+}
+export function isLidJid(jid) {
+    return isJidType(jid, WA_DEFAULTS.LID_SERVER);
 }
 export function isGroupJid(jid) {
     return isJidType(jid, WA_DEFAULTS.GROUP_SERVER);
@@ -76,9 +82,17 @@ export function parseSignalAddressFromJid(jid) {
     if (colonIndex === -1 || colonIndex > atIndex) {
         return { user: jid.slice(0, atIndex), server, device: 0 };
     }
-    const device = Number.parseInt(jid.slice(colonIndex + 1, atIndex), 10);
-    if (!Number.isFinite(device) || device < 0)
+    if (colonIndex >= atIndex - 1)
         throw new Error(`invalid jid device: ${jid}`);
+    let device = 0;
+    for (let i = colonIndex + 1; i < atIndex; i += 1) {
+        const digit = jid.charCodeAt(i) - 48;
+        if (digit < 0 || digit > 9)
+            throw new Error(`invalid jid device: ${jid}`);
+        device = device * 10 + digit;
+        if (device > Number.MAX_SAFE_INTEGER)
+            throw new Error(`invalid jid device: ${jid}`);
+    }
     return { user: jid.slice(0, colonIndex), server, device };
 }
 export function parseJidFull(jid) {
@@ -102,8 +116,18 @@ export function canonicalizeSignalJid(jid, hostDomain = WA_DEFAULTS.HOST_DOMAIN)
     return `${address.user}:${address.device}@${server}`;
 }
 export function toUserJid(jid, options = {}) {
+    const canonicalize = options.canonicalizeSignalServer === true;
+    if (!canonicalize) {
+        const atIndex = jid.indexOf('@');
+        if (atIndex >= 1 && atIndex < jid.length - 1) {
+            const colonIndex = jid.indexOf(':', 0);
+            if (colonIndex === -1 || colonIndex > atIndex) {
+                return jid;
+            }
+        }
+    }
     const address = parseSignalAddressFromJid(jid);
-    const server = options.canonicalizeSignalServer === true
+    const server = canonicalize
         ? canonicalizeSignalServer(address.server ?? WA_DEFAULTS.HOST_DOMAIN, options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN)
         : address.server;
     return `${address.user}@${server}`;
@@ -121,16 +145,26 @@ export function isHostedServer(server) {
     return server === WA_DEFAULTS.HOSTED_SERVER || server === WA_DEFAULTS.HOSTED_LID_SERVER;
 }
 export function isHostedDeviceJid(jid) {
-    const { user, server } = splitJid(jid);
-    if (isHostedServer(server)) {
+    if (isJidType(jid, WA_DEFAULTS.HOSTED_SERVER) ||
+        isJidType(jid, WA_DEFAULTS.HOSTED_LID_SERVER)) {
         return true;
     }
-    const colonIndex = user.indexOf(':');
-    if (colonIndex < 0) {
+    const atIndex = jid.indexOf('@');
+    if (atIndex < 1 || atIndex >= jid.length - 1)
+        return false;
+    const colonIndex = jid.indexOf(':');
+    if (colonIndex < 0 || colonIndex >= atIndex - 1)
         return false;
+    let deviceId = 0;
+    for (let i = colonIndex + 1; i < atIndex; i += 1) {
+        const digit = jid.charCodeAt(i) - 48;
+        if (digit < 0 || digit > 9)
+            return false;
+        deviceId = deviceId * 10 + digit;
+        if (deviceId > Number.MAX_SAFE_INTEGER)
+            return false;
     }
-    const deviceId = Number.parseInt(user.slice(colonIndex + 1), 10);
-    return Number.isSafeInteger(deviceId) && isHostedDeviceId(deviceId);
+    return isHostedDeviceId(deviceId);
 }
 export function buildDeviceJid(user, normalizedServer, deviceId, options = {}) {
     if (options.isHosted === true) {

package/dist/esm/protocol/nodes.js

@@ -32,6 +32,7 @@ export const WA_NODE_TAGS = Object.freeze({
     DESCRIPTION: 'description',
     MY_ADDONS: 'my_addons',
     KEY: 'key',
+    OP: 'op',
     REGISTRATION: 'registration',
     TYPE: 'type',
     IDENTITY: 'identity',
@@ -60,7 +61,8 @@ export const WA_NODE_TAGS = Object.freeze({
     ANNOUNCEMENT: 'announcement',
     EPHEMERAL: 'ephemeral',
     MEMBERSHIP_APPROVAL_MODE: 'membership_approval_mode',
-    GROUP_JOIN: 'group_join'
+    GROUP_JOIN: 'group_join',
+    ABPROPS: 'abprops'
 });
 export const WA_IQ_TYPES = Object.freeze({
     GET: 'get',
@@ -83,5 +85,7 @@ export const WA_XMLNS = Object.freeze({
     GROUPS: 'w:g2',
     NEWSLETTER: 'newsletter',
     XMPP_PING: 'urn:xmpp:ping',
-    WHATSAPP_PING: 'w:p'
+    WHATSAPP_PING: 'w:p',
+    ABPROPS: 'abt',
+    MEX: 'w:mex'
 });

package/dist/esm/protocol/notification.js

@@ -1,7 +1,13 @@
 export const WA_NOTIFICATION_TYPES = Object.freeze({
     GROUP: 'w:gp2',
     ENCRYPT: 'encrypt',
-    DEVICES: 'devices'
+    DEVICES: 'devices',
+    SERVER: 'server',
+    REGISTRATION: 'registration'
+});
+export const WA_REGISTRATION_NOTIFICATION_TAGS = Object.freeze({
+    WA_OLD_REGISTRATION: 'wa_old_registration',
+    DEVICE_LOGOUT: 'device_logout'
 });
 export const WA_GROUP_NOTIFICATION_TAGS = Object.freeze({
     REMOVE: 'remove',

package/dist/esm/retry/reason.js

@@ -46,5 +46,5 @@ export function mapRetryReasonFromError(error) {
             return matcher.code;
         }
     }
-    return RETRY_REASON.UnknownError;
+    return undefined;
 }

package/dist/esm/signal/api/SignalDeviceSyncApi.js

@@ -327,7 +327,10 @@ export class SignalDeviceSyncApi {
             return [];
         }
         const parsedNormalizedUser = splitJid(normalizedUserJid);
-        const parsedRawUser = splitJid(rawUserJid);
+        const rawAtIndex = rawUserJid.indexOf('@');
+        const rawServer = rawAtIndex >= 1 && rawAtIndex < rawUserJid.length - 1
+            ? rawUserJid.slice(rawAtIndex + 1)
+            : parsedNormalizedUser.server;
         const dedup = new Set();
         for (const deviceNode of getNodeChildrenByTag(deviceListNode, 'device')) {
             const parsedId = deviceNode.attrs.id
@@ -338,7 +341,7 @@ export class SignalDeviceSyncApi {
             }
             const isHostedDevice = isHostedDeviceId(parsedId) || deviceNode.attrs.is_hosted === 'true';
             dedup.add(buildDeviceJid(parsedNormalizedUser.user, parsedNormalizedUser.server, parsedId, {
-                rawServer: parsedRawUser.server,
+                rawServer,
                 isHosted: isHostedDevice
             }));
         }

package/dist/esm/signal/api/SignalDigestSyncApi.js

@@ -1,4 +1,5 @@
 import { sha1 } from '../../crypto/index.js';
+import { toRawPubKey } from '../../crypto/core/keys.js';
 import { WA_DEFAULTS, WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from '../../protocol/constants.js';
 import { decodeExactLength, parseUint } from '../api/codec.js';
 import { SIGNAL_KEY_BUNDLE_TYPE_BYTES, SIGNAL_KEY_BUNDLE_TYPE_LENGTH, SIGNAL_KEY_DATA_LENGTH, SIGNAL_KEY_ID_LENGTH, SIGNAL_REGISTRATION_ID_LENGTH, SIGNAL_SIGNATURE_LENGTH } from '../api/constants.js';
@@ -10,6 +11,7 @@ export class SignalDigestSyncApi {
         this.logger = options.logger;
         this.query = options.query;
         this.signalStore = options.signalStore;
+        this.preKeyStore = options.preKeyStore;
         this.defaultTimeoutMs =
             options.defaultTimeoutMs ?? WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
@@ -82,7 +84,7 @@ export class SignalDigestSyncApi {
                 preKeyCount: digest.preKeyIds.length
             };
         }
-        if (!uint8Equal(registrationInfo.identityKeyPair.pubKey, digest.identity)) {
+        if (!uint8Equal(toRawPubKey(registrationInfo.identityKeyPair.pubKey), toRawPubKey(digest.identity))) {
             return {
                 valid: false,
                 shouldReupload: true,
@@ -91,7 +93,7 @@ export class SignalDigestSyncApi {
             };
         }
         if (signedPreKey.keyId !== digest.signedKey.id ||
-            !uint8Equal(signedPreKey.keyPair.pubKey, digest.signedKey.publicKey) ||
+            !uint8Equal(toRawPubKey(signedPreKey.keyPair.pubKey), toRawPubKey(digest.signedKey.publicKey)) ||
             !uint8Equal(signedPreKey.signature, digest.signedKey.signature)) {
             return {
                 valid: false,
@@ -100,10 +102,10 @@ export class SignalDigestSyncApi {
                 preKeyCount: digest.preKeyIds.length
             };
         }
-        const preKeys = await this.signalStore.getPreKeysById(digest.preKeyIds);
+        const preKeys = await this.preKeyStore.getPreKeysById(digest.preKeyIds);
         const bytesToHash = [
-            registrationInfo.identityKeyPair.pubKey,
-            signedPreKey.keyPair.pubKey,
+            toRawPubKey(registrationInfo.identityKeyPair.pubKey),
+            toRawPubKey(signedPreKey.keyPair.pubKey),
             signedPreKey.signature
         ];
         for (let index = 0; index < preKeys.length; index += 1) {
@@ -116,7 +118,7 @@ export class SignalDigestSyncApi {
                     preKeyCount: digest.preKeyIds.length
                 };
             }
-            bytesToHash.push(preKey.keyPair.pubKey);
+            bytesToHash.push(toRawPubKey(preKey.keyPair.pubKey));
         }
         const localHash = (await sha1(concatBytes(bytesToHash))).subarray(0, digest.hash.byteLength);
         if (!uint8Equal(localHash, digest.hash)) {

package/dist/esm/signal/api/SignalIdentitySyncApi.js

@@ -11,7 +11,7 @@ export class SignalIdentitySyncApi {
         this.syncDedup = new PromiseDedup();
         this.logger = options.logger;
         this.query = options.query;
-        this.signalStore = options.signalStore;
+        this.identityStore = options.identityStore;
         this.defaultTimeoutMs =
             options.defaultTimeoutMs ?? WA_DEFAULTS.SIGNAL_FETCH_KEY_BUNDLES_TIMEOUT_MS;
         this.hostDomain = options.hostDomain ?? WA_DEFAULTS.HOST_DOMAIN;
@@ -66,8 +66,8 @@ export class SignalIdentitySyncApi {
             ]
         }, timeoutMs);
         const entries = this.parseIdentitySyncResponse(response, normalizedTargets);
-        const { signalStore } = this;
-        if (signalStore && entries.length > 0) {
+        const { identityStore } = this;
+        if (identityStore && entries.length > 0) {
             const identities = new Array(entries.length);
             for (let index = 0; index < entries.length; index += 1) {
                 const entry = entries[index];
@@ -76,7 +76,7 @@ export class SignalIdentitySyncApi {
                     identityKey: toSerializedPubKey(entry.identity)
                 };
             }
-            await signalStore.setRemoteIdentities(identities);
+            await identityStore.setRemoteIdentities(identities);
         }
         this.logger.debug('signal identity sync success', {
             requested: normalizedTargets.length,

package/dist/esm/signal/api/SignalMissingPreKeysSyncApi.js

@@ -4,7 +4,7 @@ import { decodeExactLength, parseUint } from '../api/codec.js';
 import { SIGNAL_KEY_DATA_LENGTH, SIGNAL_KEY_ID_LENGTH, SIGNAL_REGISTRATION_ID_LENGTH, SIGNAL_SIGNATURE_LENGTH } from '../api/constants.js';
 import { buildMissingPreKeysFetchIq } from '../api/prekeys.js';
 import { registerParsedResultByRawAndCanonicalKey } from '../api/result-map.js';
-import { decodeNodeContentBase64OrBytes, findNodeChildrenByTags, findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
+import { decodeNodeContentBase64OrBytes, findNodeChild, findNodeChildrenByTags, getNodeChildrenByTag } from '../../transport/node/helpers.js';
 import { assertIqResult } from '../../transport/node/query.js';
 function isMissingPreKeysUserResultPreferred(result) {
     return 'devices' in result;

package/dist/esm/signal/api/SignalSessionSyncApi.js

@@ -3,7 +3,7 @@ import { canonicalizeSignalJid } from '../../protocol/jid.js';
 import { decodeExactLength, parseUint } from '../api/codec.js';
 import { SIGNAL_KEY_DATA_LENGTH, SIGNAL_KEY_ID_LENGTH, SIGNAL_REGISTRATION_ID_LENGTH, SIGNAL_SIGNATURE_LENGTH } from '../api/constants.js';
 import { registerParsedResultByRawAndCanonicalKey } from '../api/result-map.js';
-import { findNodeChild, getNodeChildrenByTag, decodeNodeContentBase64OrBytes } from '../../transport/node/helpers.js';
+import { decodeNodeContentBase64OrBytes, findNodeChild, getNodeChildrenByTag } from '../../transport/node/helpers.js';
 import { assertIqResult } from '../../transport/node/query.js';
 function isKeyBundleResultPreferred(result) {
     return 'bundle' in result;

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

@@ -1,62 +1,16 @@
-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';
+import { hmacSign, importHmacKey, toRawPubKey, xeddsaSign, xeddsaVerify } from '../../crypto/index.js';
+import { ADV_PREFIX_ACCOUNT_SIGNATURE, ADV_PREFIX_DEVICE_SIGNATURE, ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE, ADV_PREFIX_HOSTED_DEVICE_SIGNATURE } from '../crypto/constants.js';
+import { 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);
+    return xeddsaVerify(toRawPubKey(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);
+    return xeddsaSign(identityKeyPair.privKey, message);
 }
 export async function computeAdvIdentityHmac(secretKey, details) {
     const key = await importHmacKey(secretKey);

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

@@ -1,7 +1,3 @@
-export const SIGNAL_PREFIX_SIGNATURE_RANDOM = new Uint8Array([
-    0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
-]);
 export const ADV_PREFIX_ACCOUNT_SIGNATURE = new Uint8Array([6, 0]);
 export const ADV_PREFIX_DEVICE_SIGNATURE = new Uint8Array([6, 1]);
 export const ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE = new Uint8Array([6, 5]);