@kelvdra/baileys 1.0.4 → 1.0.5

package/lib/Types/Mex.js

@@ -0,0 +1,37 @@
+export var XWAPaths;
+(function (XWAPaths) {
+    XWAPaths["xwa2_newsletter_create"] = "xwa2_newsletter_create";
+    XWAPaths["xwa2_newsletter_subscribers"] = "xwa2_newsletter_subscribers";
+    XWAPaths["xwa2_newsletter_view"] = "xwa2_newsletter_view";
+    XWAPaths["xwa2_newsletter_metadata"] = "xwa2_newsletter";
+    XWAPaths["xwa2_newsletter_admin_count"] = "xwa2_newsletter_admin";
+    XWAPaths["xwa2_newsletter_mute_v2"] = "xwa2_newsletter_mute_v2";
+    XWAPaths["xwa2_newsletter_unmute_v2"] = "xwa2_newsletter_unmute_v2";
+    XWAPaths["xwa2_newsletter_follow"] = "xwa2_newsletter_follow";
+    XWAPaths["xwa2_newsletter_unfollow"] = "xwa2_newsletter_unfollow";
+    XWAPaths["xwa2_newsletter_join_v2"] = "xwa2_newsletter_join_v2";
+    XWAPaths["xwa2_newsletter_leave_v2"] = "xwa2_newsletter_leave_v2";
+    XWAPaths["xwa2_newsletter_change_owner"] = "xwa2_newsletter_change_owner";
+    XWAPaths["xwa2_newsletter_demote"] = "xwa2_newsletter_demote";
+    XWAPaths["xwa2_newsletter_delete_v2"] = "xwa2_newsletter_delete_v2";
+    XWAPaths["xwa2_fetch_account_reachout_timelock"] = "xwa2_fetch_account_reachout_timelock";
+    XWAPaths["xwa2_message_capping_info"] = "xwa2_message_capping_info";
+})(XWAPaths || (XWAPaths = {}));
+export var QueryIds;
+(function (QueryIds) {
+    QueryIds["CREATE"] = "8823471724422422";
+    QueryIds["UPDATE_METADATA"] = "24250201037901610";
+    QueryIds["METADATA"] = "6563316087068696";
+    QueryIds["SUBSCRIBERS"] = "9783111038412085";
+    QueryIds["FOLLOW"] = "24404358912487870";
+    QueryIds["UNFOLLOW"] = "9767147403369991";
+    QueryIds["MUTE"] = "29766401636284406";
+    QueryIds["UNMUTE"] = "9864994326891137";
+    QueryIds["ADMIN_COUNT"] = "7130823597031706";
+    QueryIds["CHANGE_OWNER"] = "7341777602580933";
+    QueryIds["DEMOTE"] = "6551828931592903";
+    QueryIds["DELETE"] = "30062808666639665";
+    QueryIds["REACHOUT_TIMELOCK"] = "23983697327930364";
+    QueryIds["MESSAGE_CAPPING_INFO"] = "24503548349331633";
+})(QueryIds || (QueryIds = {}));
+//# sourceMappingURL=Mex.js.map

package/lib/Types/State.js

@@ -10,4 +10,57 @@ export var SyncState;
     /** Initial sync is complete, or was skipped. The socket is fully operational and events are processed in real-time. */
     SyncState[SyncState["Online"] = 3] = "Online";
 })(SyncState || (SyncState = {}));
-//# sourceMappingURL=State.js.map
+//# sourceMappingURL=State.js.map
+
+// Added from Baileys v7.0.0-rc10
+export var NewChatMessageCappingMVStatusType;
+(function (NewChatMessageCappingMVStatusType) {
+    NewChatMessageCappingMVStatusType["NOT_ELIGIBLE"] = "NOT_ELIGIBLE";
+    NewChatMessageCappingMVStatusType["NOT_ACTIVE"] = "NOT_ACTIVE";
+    NewChatMessageCappingMVStatusType["ACTIVE"] = "ACTIVE";
+    NewChatMessageCappingMVStatusType["ACTIVE_UPGRADE_AVAILABLE"] = "ACTIVE_UPGRADE_AVAILABLE";
+})(NewChatMessageCappingMVStatusType || (NewChatMessageCappingMVStatusType = {}));
+
+// Added from Baileys v7.0.0-rc10
+export var NewChatMessageCappingOTEStatusType;
+(function (NewChatMessageCappingOTEStatusType) {
+    NewChatMessageCappingOTEStatusType["NOT_ELIGIBLE"] = "NOT_ELIGIBLE";
+    NewChatMessageCappingOTEStatusType["ELIGIBLE"] = "ELIGIBLE";
+    NewChatMessageCappingOTEStatusType["ACTIVE_IN_CURRENT_CYCLE"] = "ACTIVE_IN_CURRENT_CYCLE";
+    NewChatMessageCappingOTEStatusType["EXHAUSTED"] = "EXHAUSTED";
+})(NewChatMessageCappingOTEStatusType || (NewChatMessageCappingOTEStatusType = {}));
+//# sourceMappingURL=State.js.map
+
+// Added from Baileys v7.0.0-rc10
+export var NewChatMessageCappingStatusType;
+(function (NewChatMessageCappingStatusType) {
+    NewChatMessageCappingStatusType["NONE"] = "NONE";
+    NewChatMessageCappingStatusType["FIRST_WARNING"] = "FIRST_WARNING";
+    NewChatMessageCappingStatusType["SECOND_WARNING"] = "SECOND_WARNING";
+    NewChatMessageCappingStatusType["CAPPED"] = "CAPPED";
+})(NewChatMessageCappingStatusType || (NewChatMessageCappingStatusType = {}));
+
+// Added from Baileys v7.0.0-rc10
+export var ReachoutTimelockEnforcementType;
+(function (ReachoutTimelockEnforcementType) {
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_ALCOHOL"] = "BIZ_COMMERCE_VIOLATION_ALCOHOL";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_ADULT"] = "BIZ_COMMERCE_VIOLATION_ADULT";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_ANIMALS"] = "BIZ_COMMERCE_VIOLATION_ANIMALS";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_BODY_PARTS_FLUIDS"] = "BIZ_COMMERCE_VIOLATION_BODY_PARTS_FLUIDS";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_DATING"] = "BIZ_COMMERCE_VIOLATION_DATING";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_DIGITAL_SERVICES_PRODUCTS"] = "BIZ_COMMERCE_VIOLATION_DIGITAL_SERVICES_PRODUCTS";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_DRUGS"] = "BIZ_COMMERCE_VIOLATION_DRUGS";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_DRUGS_ONLY_OTC"] = "BIZ_COMMERCE_VIOLATION_DRUGS_ONLY_OTC";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_GAMBLING"] = "BIZ_COMMERCE_VIOLATION_GAMBLING";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_HEALTHCARE"] = "BIZ_COMMERCE_VIOLATION_HEALTHCARE";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_REAL_FAKE_CURRENCY"] = "BIZ_COMMERCE_VIOLATION_REAL_FAKE_CURRENCY";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_SUPPLEMENTS"] = "BIZ_COMMERCE_VIOLATION_SUPPLEMENTS";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_TOBACCO"] = "BIZ_COMMERCE_VIOLATION_TOBACCO";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_VIOLENT_CONTENT"] = "BIZ_COMMERCE_VIOLATION_VIOLENT_CONTENT";
+    ReachoutTimelockEnforcementType["BIZ_COMMERCE_VIOLATION_WEAPONS"] = "BIZ_COMMERCE_VIOLATION_WEAPONS";
+    ReachoutTimelockEnforcementType["BIZ_QUALITY"] = "BIZ_QUALITY";
+    /** This means there is no restriction */
+    ReachoutTimelockEnforcementType["DEFAULT"] = "DEFAULT";
+    ReachoutTimelockEnforcementType["WEB_COMPANION_ONLY"] = "WEB_COMPANION_ONLY";
+})(ReachoutTimelockEnforcementType || (ReachoutTimelockEnforcementType = {}));
+

package/lib/Utils/auth-utils.js

@@ -7,6 +7,7 @@ import { DEFAULT_CACHE_TTLS } from '../Defaults/index.js';
 import { Curve, signedKeyPair } from './crypto.js';
 import { delay, generateRegistrationId } from './generics.js';
 import { PreKeyManager } from './pre-key-manager.js';
+import { Boom } from '@hapi/boom';
 /**
  * Adds caching capability to a SignalKeyStore
  * @param store the store to add caching to
@@ -254,4 +255,14 @@ export const initAuthCreds = () => {
         additionalData: undefined
     };
 };
-//# sourceMappingURL=auth-utils.js.map
+//# sourceMappingURL=auth-utils.js.map
+
+// Added from Baileys v7.0.0-rc10
+export const assertMeId = (creds) => {
+    const id = creds.me?.id;
+    if (!id) {
+        throw new Boom('Cannot proceed: socket is not authenticated yet (creds.me.id is missing)', { statusCode: 401 });
+    }
+    return id;
+};
+

package/lib/Utils/chat-utils.js

@@ -6,6 +6,8 @@ import { aesDecrypt, aesEncrypt, hkdf, hmacSign } from './crypto.js';
 import { toNumber } from './generics.js';
 import { LT_HASH_ANTI_TAMPERING } from './lt-hash.js';
 import { downloadContentFromMessage } from './messages-media.js';
+import { expandAppStateKeys } from 'whatsapp-rust-bridge';
+import { emitSyncActionResults, processContactAction } from './sync-action-utils.js';
 const mutationKeys = async (keydata) => {
     const expanded = await hkdf(keydata, 160, { info: 'WhatsApp Mutation Keys' });
     return {
@@ -42,7 +44,7 @@ const to64BitNetworkOrder = (e) => {
     buff.writeUint32BE(e, 4);
     return buff;
 };
-const makeLtHashGenerator = ({ indexValueMap, hash }) => {
+export const makeLtHashGenerator = ({ indexValueMap, hash }) => {
     indexValueMap = { ...indexValueMap };
     const addBuffs = [];
     const subBuffs = [];
@@ -760,4 +762,36 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
         return lastMsgTimestamp >= chatLastMsgTimestamp;
     }
 };
-//# sourceMappingURL=chat-utils.js.map
+//# sourceMappingURL=chat-utils.js.map
+
+// Added from Baileys v7.0.0-rc10
+export const MAX_SYNC_ATTEMPTS = 2;
+/**
+ * Check if an error is a missing app state sync key.
+ * WA Web treats these as "Blocked" (waits for key arrival), not fatal.
+ * In Baileys we retry with a snapshot which may use a different key.
+ */
+
+// Added from Baileys v7.0.0-rc10
+export const ensureLTHashStateVersion = (state) => {
+    if (typeof state.version !== 'number' || isNaN(state.version)) {
+        state.version = 0;
+    }
+    return state;
+};
+
+// Added from Baileys v7.0.0-rc10
+export const isAppStateSyncIrrecoverable = (error, attempts) => {
+    return attempts >= MAX_SYNC_ATTEMPTS || error?.name === 'TypeError';
+};
+
+// Added from Baileys v7.0.0-rc10
+export const isMissingKeyError = (error) => {
+    return error?.data?.isMissingKey === true;
+};
+/**
+ * Determines if an app state sync error is unrecoverable.
+ * TypeError indicates a WASM crash; otherwise we give up after MAX_SYNC_ATTEMPTS.
+ * Missing keys are NOT checked here — they are handled separately as "Blocked".
+ */
+

package/lib/Utils/companion-reg-client-utils.d.ts

@@ -0,0 +1,17 @@
+import type { WABrowserDescription } from '../Types/index.js';
+export declare enum CompanionWebClientType {
+    UNKNOWN = 0,
+    CHROME = 1,
+    EDGE = 2,
+    FIREFOX = 3,
+    IE = 4,
+    OPERA = 5,
+    SAFARI = 6,
+    ELECTRON = 7,
+    UWP = 8,
+    OTHER_WEB_CLIENT = 9
+}
+export declare const getCompanionWebClientType: ([os, browserName]: WABrowserDescription) => CompanionWebClientType;
+export declare const getCompanionPlatformId: (browser: WABrowserDescription) => string;
+export declare const buildPairingQRData: (ref: string, noiseKeyB64: string, identityKeyB64: string, advB64: string, browser: WABrowserDescription) => string;
+//# sourceMappingURL=companion-reg-client-utils.d.ts.map

package/lib/Utils/companion-reg-client-utils.js

@@ -0,0 +1,35 @@
+export var CompanionWebClientType;
+(function (CompanionWebClientType) {
+    CompanionWebClientType[CompanionWebClientType["UNKNOWN"] = 0] = "UNKNOWN";
+    CompanionWebClientType[CompanionWebClientType["CHROME"] = 1] = "CHROME";
+    CompanionWebClientType[CompanionWebClientType["EDGE"] = 2] = "EDGE";
+    CompanionWebClientType[CompanionWebClientType["FIREFOX"] = 3] = "FIREFOX";
+    CompanionWebClientType[CompanionWebClientType["IE"] = 4] = "IE";
+    CompanionWebClientType[CompanionWebClientType["OPERA"] = 5] = "OPERA";
+    CompanionWebClientType[CompanionWebClientType["SAFARI"] = 6] = "SAFARI";
+    CompanionWebClientType[CompanionWebClientType["ELECTRON"] = 7] = "ELECTRON";
+    CompanionWebClientType[CompanionWebClientType["UWP"] = 8] = "UWP";
+    CompanionWebClientType[CompanionWebClientType["OTHER_WEB_CLIENT"] = 9] = "OTHER_WEB_CLIENT";
+})(CompanionWebClientType || (CompanionWebClientType = {}));
+const BROWSER_TO_COMPANION_WEB_CLIENT = {
+    Chrome: CompanionWebClientType.CHROME,
+    Edge: CompanionWebClientType.EDGE,
+    Firefox: CompanionWebClientType.FIREFOX,
+    IE: CompanionWebClientType.IE,
+    Opera: CompanionWebClientType.OPERA,
+    Safari: CompanionWebClientType.SAFARI
+};
+export const getCompanionWebClientType = ([os, browserName]) => {
+    if (browserName === 'Desktop') {
+        return os === 'Windows' ? CompanionWebClientType.UWP : CompanionWebClientType.ELECTRON;
+    }
+    return BROWSER_TO_COMPANION_WEB_CLIENT[browserName] || CompanionWebClientType.OTHER_WEB_CLIENT;
+};
+export const getCompanionPlatformId = (browser) => {
+    return getCompanionWebClientType(browser).toString();
+};
+export const buildPairingQRData = (ref, noiseKeyB64, identityKeyB64, advB64, browser) => {
+    return ('https://wa.me/settings/linked_devices#' +
+        [ref, noiseKeyB64, identityKeyB64, advB64, getCompanionPlatformId(browser)].join(','));
+};
+//# sourceMappingURL=companion-reg-client-utils.js.map

package/lib/Utils/decode-wa-message.js

@@ -137,6 +137,9 @@ export function decodeMessageNode(stanza, meId, meLid) {
         msgType = 'newsletter';
         chatId = from;
         author = from;
+        if (isMe(from) || isMeLid(from)) {
+            fromMe = true;
+        }
     }
     else {
         throw new Boom('Unknown message type', { data: stanza });
@@ -144,13 +147,12 @@ export function decodeMessageNode(stanza, meId, meLid) {
     const pushname = stanza?.attrs?.notify;
     const key = {
         remoteJid: chatId,
+        remoteJidAlt: !isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
         fromMe,
         id: msgId,
-        senderLid: stanza?.attrs?.sender_lid,
-        senderPn: stanza?.attrs?.sender_pn,
         participant,
-        participantPn: stanza?.attrs?.participant_pn,
-        participantLid: stanza?.attrs?.participant_lid,
+        participantAlt: isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
+        addressingMode: addressingContext.addressingMode,
         ...(msgType === 'newsletter' && stanza.attrs.server_id ? { server_id: stanza.attrs.server_id } : {})
     };
     const fullMessage = {
@@ -279,3 +281,20 @@ function isSessionRecordError(error) {
     return DECRYPTION_RETRY_CONFIG.sessionRecordErrors.some(errorPattern => errorMessage.includes(errorPattern));
 }
 //# sourceMappingURL=decode-wa-message.js.map
+
+// Added from Baileys v7.0.0-rc10
+export const ACCOUNT_RESTRICTED_TEXT = 'Your account has been restricted';
+// Retry configuration for failed decryption
+
+// Added from Baileys v7.0.0-rc10
+export const SERVER_ERROR_CODES = {
+    /**
+     * 1:1 message missing privacy token (tctoken). Usually means the account is
+     * restricted: WhatsApp blocks starting new chats but preserves existing ones,
+     * since established chats already carry a tctoken.
+     */
+    MessageAccountRestriction: '463',
+    /** Stanza validation failure (SMAX_INVALID) — likely stale device session */
+    SmaxInvalid: '479'
+};
+

package/lib/Utils/generics.js

@@ -36,6 +36,9 @@ export const writeRandomPadMax16 = (msg) => {
     const padLength = (pad[0] & 0x0f) + 1;
     return Buffer.concat([msg, Buffer.alloc(padLength, padLength)]);
 };
+export const isStringNullOrEmpty = (value) => 
+// eslint-disable-next-line eqeqeq
+value == null || value === '';
 export const unpadRandomMax16 = (e) => {
     const t = new Uint8Array(e);
     if (0 === t.length) {
@@ -378,4 +381,4 @@ export function bytesToCrockford(buffer) {
 export function encodeNewsletterMessage(message) {
     return proto.Message.encode(message).finish();
 }
-//# sourceMappingURL=generics.js.map
+//# sourceMappingURL=generics.js.map

package/lib/Utils/identity-change-handler.d.ts

@@ -0,0 +1,44 @@
+import NodeCache from '@cacheable/node-cache';
+import { type BinaryNode } from '../WABinary/index.js';
+import type { ILogger } from './logger.js';
+export type IdentityChangeResult = {
+    action: 'no_identity_node';
+} | {
+    action: 'invalid_notification';
+} | {
+    action: 'skipped_companion_device';
+    device: number;
+} | {
+    action: 'skipped_self_primary';
+} | {
+    action: 'debounced';
+} | {
+    action: 'skipped_offline';
+} | {
+    action: 'skipped_no_session';
+} | {
+    action: 'session_refreshed';
+} | {
+    action: 'session_refresh_failed';
+    error: unknown;
+};
+export type IdentityChangeContext = {
+    meId: string | undefined;
+    meLid: string | undefined;
+    validateSession: (jid: string) => Promise<{
+        exists: boolean;
+        reason?: string;
+    }>;
+    assertSessions: (jids: string[], force?: boolean) => Promise<boolean>;
+    debounceCache: NodeCache<boolean>;
+    logger: ILogger;
+    /**
+     * Invoked right before `assertSessions` is called for an existing-session identity change.
+     * Used to kick off fire-and-forget side effects (e.g. tctoken re-issuance) in the same
+     * order WA Web does — i.e. before the E2E session is re-established.
+     * Must not throw; implementations are responsible for their own error handling.
+     */
+    onBeforeSessionRefresh?: (jid: string) => void;
+};
+export declare function handleIdentityChange(node: BinaryNode, ctx: IdentityChangeContext): Promise<IdentityChangeResult>;
+//# sourceMappingURL=identity-change-handler.d.ts.map

package/lib/Utils/identity-change-handler.js

@@ -0,0 +1,50 @@
+import NodeCache from '@cacheable/node-cache';
+import { areJidsSameUser, getBinaryNodeChild, jidDecode } from '../WABinary/index.js';
+import { isStringNullOrEmpty } from './generics.js';
+export async function handleIdentityChange(node, ctx) {
+    const from = node.attrs.from;
+    if (!from) {
+        return { action: 'invalid_notification' };
+    }
+    const identityNode = getBinaryNodeChild(node, 'identity');
+    if (!identityNode) {
+        return { action: 'no_identity_node' };
+    }
+    ctx.logger.info({ jid: from }, 'identity changed');
+    const decoded = jidDecode(from);
+    if (decoded?.device && decoded.device !== 0) {
+        ctx.logger.debug({ jid: from, device: decoded.device }, 'ignoring identity change from companion device');
+        return { action: 'skipped_companion_device', device: decoded.device };
+    }
+    const isSelfPrimary = ctx.meId && (areJidsSameUser(from, ctx.meId) || (ctx.meLid && areJidsSameUser(from, ctx.meLid)));
+    if (isSelfPrimary) {
+        ctx.logger.info({ jid: from }, 'self primary identity changed');
+        return { action: 'skipped_self_primary' };
+    }
+    if (ctx.debounceCache.get(from)) {
+        ctx.logger.debug({ jid: from }, 'skipping identity assert (debounced)');
+        return { action: 'debounced' };
+    }
+    ctx.debounceCache.set(from, true);
+    const isOfflineNotification = !isStringNullOrEmpty(node.attrs.offline);
+    const hasExistingSession = await ctx.validateSession(from);
+    if (!hasExistingSession.exists) {
+        ctx.logger.debug({ jid: from }, 'no old session, skipping session refresh');
+        return { action: 'skipped_no_session' };
+    }
+    ctx.logger.debug({ jid: from }, 'old session exists, will refresh session');
+    if (isOfflineNotification) {
+        ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing');
+        return { action: 'skipped_offline' };
+    }
+    ctx.onBeforeSessionRefresh?.(from);
+    try {
+        await ctx.assertSessions([from], true);
+        return { action: 'session_refreshed' };
+    }
+    catch (error) {
+        ctx.logger.warn({ error, jid: from }, 'failed to assert sessions after identity change');
+        return { action: 'session_refresh_failed', error };
+    }
+}
+//# sourceMappingURL=identity-change-handler.js.map

package/lib/Utils/index.js

@@ -16,4 +16,4 @@ export * from './event-buffer.js';
 export * from './process-message.js';
 export * from './message-retry-manager.js';
 export * from './browser-utils.js';
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/lib/Utils/message-retry-manager.js

@@ -169,4 +169,28 @@ export class MessageRetryManager {
         this.messageKeyIndex.delete(messageId);
     }
 }
-//# sourceMappingURL=message-retry-manager.js.map
+//# sourceMappingURL=message-retry-manager.js.map
+
+// Added from Baileys v7.0.0-rc10
+export var RetryReason;
+(function (RetryReason) {
+    RetryReason[RetryReason["UnknownError"] = 0] = "UnknownError";
+    RetryReason[RetryReason["SignalErrorNoSession"] = 1] = "SignalErrorNoSession";
+    RetryReason[RetryReason["SignalErrorInvalidKey"] = 2] = "SignalErrorInvalidKey";
+    RetryReason[RetryReason["SignalErrorInvalidKeyId"] = 3] = "SignalErrorInvalidKeyId";
+    /** MAC verification failed - most common cause of decryption failures */
+    RetryReason[RetryReason["SignalErrorInvalidMessage"] = 4] = "SignalErrorInvalidMessage";
+    RetryReason[RetryReason["SignalErrorInvalidSignature"] = 5] = "SignalErrorInvalidSignature";
+    RetryReason[RetryReason["SignalErrorFutureMessage"] = 6] = "SignalErrorFutureMessage";
+    /** Explicit MAC failure - session is definitely out of sync */
+    RetryReason[RetryReason["SignalErrorBadMac"] = 7] = "SignalErrorBadMac";
+    RetryReason[RetryReason["SignalErrorInvalidSession"] = 8] = "SignalErrorInvalidSession";
+    RetryReason[RetryReason["SignalErrorInvalidMsgKey"] = 9] = "SignalErrorInvalidMsgKey";
+    RetryReason[RetryReason["BadBroadcastEphemeralSetting"] = 10] = "BadBroadcastEphemeralSetting";
+    RetryReason[RetryReason["UnknownCompanionNoPrekey"] = 11] = "UnknownCompanionNoPrekey";
+    RetryReason[RetryReason["AdvFailure"] = 12] = "AdvFailure";
+    RetryReason[RetryReason["StatusRevokeDelay"] = 13] = "StatusRevokeDelay";
+})(RetryReason || (RetryReason = {}));
+/** Error codes that indicate a MAC failure and require immediate session recreation */
+const MAC_ERROR_CODES = new Set([RetryReason.SignalErrorInvalidMessage, RetryReason.SignalErrorBadMac]);
+