amiudmodz 6.2.2 → 6.2.5

package/lib/Socket/index.js

@@ -1,12 +1,41 @@
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
 import { makeCommunitiesSocket } from './communities.js';
+import { wrapSocket } from 'baileys-antiban';
 // export the last socket layer
 const makeWASocket = (config) => {
     const newConfig = {
         ...DEFAULT_CONNECTION_CONFIG,
         ...config
     };
-    return makeCommunitiesSocket(newConfig);
+    const sock = makeCommunitiesSocket(newConfig);
+    // Lazy initialization & helpers for VoIP Voice & Video Calling
+    let voipClient = null;
+    const getVoipClient = async () => {
+        if (!voipClient) {
+            // @ts-ignore
+            const { VoipClient } = await import('../../VoIP/index.js');
+            voipClient = new VoipClient(newConfig);
+            await voipClient.connectWithSocket(sock);
+        }
+        return voipClient;
+    };
+    const call = async (number, opts = {}) => {
+        const client = await getVoipClient();
+        return client.call(number, opts);
+    };
+    call.voice = async (number, opts = {}) => {
+        return call(number, { ...opts, type: 'voice', isVideo: false });
+    };
+    call.video = async (number, opts = {}) => {
+        return call(number, { ...opts, type: 'video', isVideo: true });
+    };
+    call.getVoipClient = getVoipClient;
+    const extendedSock = Object.assign(sock, { call });
+    if (config.antiban !== false) {
+        const antibanConfig = typeof config.antiban === 'object' ? config.antiban : undefined;
+        return wrapSocket(extendedSock, antibanConfig);
+    }
+    return extendedSock;
 };
 export default makeWASocket;
 //# sourceMappingURL=index.js.map

package/lib/Socket/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Socket/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAErD,+BAA+B;AAC/B,MAAM,YAAY,GAAG,CAAC,MAA8B,EAAE,EAAE;IACvD,MAAM,SAAS,GAAG;QACjB,GAAG,yBAAyB;QAC5B,GAAG,MAAM;KACT,CAAA;IAED,OAAO,qBAAqB,CAAC,SAAS,CAAC,CAAA;AACxC,CAAC,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Socket/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C,+BAA+B;AAC/B,MAAM,YAAY,GAAG,CAAC,MAA8B,EAA4C,EAAE;IACjG,MAAM,SAAS,GAAG;QACjB,GAAG,yBAAyB;QAC5B,GAAG,MAAM;KACT,CAAA;IAED,MAAM,IAAI,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAA;IAE7C,+DAA+D;IAC/D,IAAI,UAAU,GAAQ,IAAI,CAAA;IAC1B,MAAM,aAAa,GAAG,KAAK,IAAI,EAAE;QAChC,IAAI,CAAC,UAAU,EAAE,CAAC;YACjB,aAAa;YACb,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,MAAM,CAAC,qBAAqB,CAAC,CAAA;YAC1D,UAAU,GAAG,IAAI,UAAU,CAAC,SAAgB,CAAC,CAAA;YAC7C,MAAM,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAA;QACzC,CAAC;QACD,OAAO,UAAU,CAAA;IAClB,CAAC,CAAA;IAED,MAAM,IAAI,GAAG,KAAK,EAAE,MAAc,EAAE,OAAmG,EAAE,EAAE,EAAE;QAC5I,MAAM,MAAM,GAAG,MAAM,aAAa,EAAE,CAAA;QACpC,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IACjC,CAAC,CAAA;IAED,IAAI,CAAC,KAAK,GAAG,KAAK,EAAE,MAAc,EAAE,OAAsD,EAAE,EAAE,EAAE;QAC/F,OAAO,IAAI,CAAC,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAA;IAChE,CAAC,CAAA;IAED,IAAI,CAAC,KAAK,GAAG,KAAK,EAAE,MAAc,EAAE,OAAsD,EAAE,EAAE,EAAE;QAC/F,OAAO,IAAI,CAAC,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA;IAC/D,CAAC,CAAA;IAED,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;IAElC,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,CAAA;IAElD,IAAI,MAAM,CAAC,OAAO,KAAK,KAAK,EAAE,CAAC;QAC9B,MAAM,aAAa,GAAG,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAA;QACrF,OAAO,UAAU,CAAC,YAAmB,EAAE,aAAa,CAAQ,CAAA;IAC7D,CAAC;IAED,OAAO,YAAY,CAAA;AACpB,CAAC,CAAA;AAED,eAAe,YAAY,CAAA"}

package/lib/Socket/messages-recv.d.ts

@@ -6,7 +6,7 @@ import type { MessageReceiptType, MessageRelayOptions, NewChatMessageCapInfo, So
 import { type BinaryNode, type JidWithDevice } from '../WABinary/index.js';
 export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     sendMessageAck: (node: BinaryNode, errorCode?: number) => Promise<void>;
-    sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
+    sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean, decryptionError?: string) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
     fetchMessageHistory: (count: number, oldestMsgKey: WAMessageKey, oldestMsgTimestamp: number | Long) => Promise<string>;
     requestPlaceholderResend: (messageKey: WAMessageKey, msgData?: Partial<WAMessage>) => Promise<string | undefined>;
@@ -17,7 +17,9 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     };
     issuePrivacyTokens: (jids: string[], timestamp?: number) => Promise<any>;
     assertSessions: (jids: string[], force?: boolean) => Promise<boolean>;
-    relayMessage: (jid: string, message: proto.IMessage, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList }: MessageRelayOptions) => Promise<string>;
+    relayMessage: (jid: string, message: proto.IMessage, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList, addBizAttributes }: MessageRelayOptions & {
+        addBizAttributes?: boolean;
+    }) => Promise<string>;
     sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: MessageReceiptType) => Promise<void>;
     sendReceipts: (keys: WAMessageKey[], type: MessageReceiptType) => Promise<void>;
     readMessages: (keys: WAMessageKey[]) => Promise<void>;
@@ -37,12 +39,8 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     })[]>;
     updateMemberLabel: (jid: string, memberLabel: string) => Promise<string>;
     updateMediaMessage: (message: WAMessage) => Promise<WAMessage>;
-    sendMessage: (jid: string, content: import("../Types/index.js").AnyMessageContent, options?: import("../Types/index.js").MiscMessageGenerationOptions) => Promise<WAMessage | undefined>;
-    sendChStatus: (jid: string, content: import("../Types/index.js").AnyMessageContent, options?: import("../Types/index.js").MiscMessageGenerationOptions) => Promise<WAMessage>;
-    sendGroupStatus: (groupJid: string, content: import("../Types/index.js").AnyMessageContent, options?: MessageRelayOptions) => Promise<any>;
-    sendChannelStatus: (channelJid: string, content: import("../Types/index.js").AnyMessageContent, options?: MessageRelayOptions) => Promise<any>;
     menurich: (jid: string, options: {
-        title?: string;
+        title: string;
         subtitle?: string;
         imageUrl?: string;
         menus?: {
@@ -58,11 +56,23 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
             url: string;
         }[];
     }) => Promise<string>;
+    sendHtmlGame: (jid: string, htmlPayload: string, options?: {
+        title?: string;
+        subtitle?: string;
+        trustedSources?: string[];
+        responseId?: string;
+        botResponseId?: string;
+        botJid?: string;
+        signature?: string;
+        certificateChain?: string[];
+    }) => Promise<string>;
+    sendMessage: (jid: string, content: import("../Types/index.js").AnyMessageContent, options?: import("../Types/index.js").MiscMessageGenerationOptions) => Promise<WAMessage | undefined>;
     newsletterCreate: (name: string, description?: string) => Promise<import("../Types/index.js").NewsletterMetadata>;
     newsletterUpdate: (jid: string, updates: import("../Types/index.js").NewsletterUpdate) => Promise<unknown>;
     newsletterSubscribers: (jid: string) => Promise<{
         subscribers: number;
     }>;
+    newsletterSubscribed: () => Promise<unknown>;
     newsletterMetadata: (type: "invite" | "jid", key: string) => Promise<import("../Types/index.js").NewsletterMetadata | null>;
     newsletterFollow: (jid: string) => Promise<unknown>;
     newsletterUnfollow: (jid: string) => Promise<unknown>;
@@ -73,7 +83,7 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     newsletterUpdatePicture: (jid: string, content: import("../Types/index.js").WAMediaUpload) => Promise<unknown>;
     newsletterRemovePicture: (jid: string) => Promise<unknown>;
     newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
-    newsletterFetchMessages: (jid: string, count: number, since: number, after: number) => Promise<any>;
+    newsletterFetchMessages: (type: "jid" | "key", key: string, count: number, after?: number, before?: number) => Promise<proto.IWebMessageInfo[]>;
     subscribeNewsletterUpdates: (jid: string) => Promise<{
         duration: string;
     } | null>;
@@ -164,16 +174,13 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: number | string) => Promise<void>;
     addOrEditContact: (jid: string, contact: proto.SyncActionValue.IContactAction) => Promise<void>;
     removeContact: (jid: string) => Promise<void>;
+    saveContact: (name: string, phoneNumber: string) => Promise<void>;
     placeholderResendCache: import("../Types/index.js").CacheStore;
     addLabel: (jid: string, labels: import("../Types/Label.js").LabelActionBody) => Promise<void>;
     addChatLabel: (jid: string, labelId: string) => Promise<void>;
     removeChatLabel: (jid: string, labelId: string) => Promise<void>;
     addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
     removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
-    star: (jid: string, messages: {
-        id: string;
-        fromMe?: boolean;
-    }[], star: boolean) => Promise<void>;
     addOrEditQuickReply: (quickReply: import("../Types/Bussines.js").QuickReplyAction) => Promise<void>;
     removeQuickReply: (timestamp: string) => Promise<void>;
     type: "md";

package/lib/Socket/messages-recv.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages-recv.d.ts","sourceRoot":"","sources":["../../src/Socket/messages-recv.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,uBAAuB,CAAA;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEjC,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAQ9C,OAAO,KAAK,EAEX,kBAAkB,EAClB,mBAAmB,EAEnB,qBAAqB,EACrB,YAAY,EAEZ,SAAS,EACT,YAAY,EAEZ,MAAM,UAAU,CAAA;AA4CjB,OAAO,EAEN,KAAK,UAAU,EAef,KAAK,aAAa,EAElB,MAAM,aAAa,CAAA;AAuBpB,eAAO,MAAM,sBAAsB,GAAI,QAAQ,YAAY;2BAobtB,UAAU,cAAc,MAAM;6BA4B5B,UAAU;yBAtBd,MAAM,YAAY,MAAM;iCAnYlD,MAAM,gBACC,YAAY,sBACN,MAAM,GAAG,IAAI,KAC/B,OAAO,CAAC,MAAM,CAAC;2CAoBL,YAAY,YACd,OAAO,CAAC,SAAS,CAAC,KAC1B,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAysCI,CAAC;gBACvB,CAAC;gBAEV,CADH;aACiB,CAAC;;;;;qBAC0D,CAAC;;;mBACrE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA7cP,CADsB;;;;;;;;;0DAv3BhB,GAAG,0BACI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsjElB,CAAA"}
+{"version":3,"file":"messages-recv.d.ts","sourceRoot":"","sources":["../../src/Socket/messages-recv.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,uBAAuB,CAAA;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEjC,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAQ9C,OAAO,KAAK,EAGX,kBAAkB,EAClB,mBAAmB,EAEnB,qBAAqB,EACrB,YAAY,EAEZ,SAAS,EACT,YAAY,EAEZ,MAAM,UAAU,CAAA;AA4CjB,OAAO,EAEN,KAAK,UAAU,EAgBf,KAAK,aAAa,EAElB,MAAM,aAAa,CAAA;AAwBpB,eAAO,MAAM,sBAAsB,GAAI,QAAQ,YAAY;2BAkctB,UAAU,cAAc,MAAM;6BA4B5B,UAAU,gDAA8C,MAAM;yBAtBlE,MAAM,YAAY,MAAM;iCAnYlD,MAAM,gBACC,YAAY,sBACN,MAAM,GAAG,IAAI,KAC/B,OAAO,CAAC,MAAM,CAAC;2CAoBL,YAAY,YACd,OAAO,CAAC,SAAS,CAAC,KAC1B,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;;;;;;;;;wBA2W3B,CAAC;;;;;;;;;;;;;;;;;;;;;;;gBAyoBkB,CAAC;gBACjB,CAAC;aAAmB,CAAC;;;;;qBAAyE,CAAC;;;mBACpE,CAAC;;;;;;aAkN1B,CAAC;gBAEL,CAAC;sBAA4B,CAAC;kBAA0B,CAAC;qBACzD,CAAC;cAAoB,CAAC;iBACR,CAAC;wBAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAp1C7C,GAAG,0BACO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2pElB,CAAA"}

package/lib/Socket/messages-recv.js

@@ -10,9 +10,10 @@ import { makeMutex } from '../Utils/make-mutex.js';
 import { makeOfflineNodeProcessor } from '../Utils/offline-node-processor.js';
 import { buildAckStanza } from '../Utils/stanza-ack.js';
 import { buildMergedTcTokenIndexWrite, isTcTokenExpired, readTcTokenIndex, resolveIssuanceJid, resolveTcTokenJid, storeTcTokensFromIqResult, TC_TOKEN_INDEX_KEY } from '../Utils/tc-token-utils.js';
-import { areJidsSameUser, binaryNodeToString, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, getBinaryNodeChildUInt, isJidGroup, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { areJidsSameUser, binaryNodeToString, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, getBinaryNodeChildUInt, isHostedLidUser, isJidGroup, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { extractGroupMetadata } from './groups.js';
 import { makeMessagesSocket } from './messages-send.js';
+import { makeShortcakeFlow } from '../Utils/shortcake.js';
 const ENFORCEMENT_TYPE_VALUES = new Set(Object.values(ReachoutTimelockEnforcementType));
 function isValidEnforcementType(value) {
     return typeof value === 'string' && ENFORCEMENT_TYPE_VALUES.has(value);
@@ -24,6 +25,19 @@ export const makeMessagesRecvSocket = (config) => {
     const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex();
+    /** Shortcake passkey flow - only active when signPasskeyAssertion is provided */
+    const shortcakeFlow = config.signPasskeyAssertion
+        ? makeShortcakeFlow({
+            logger: logger.child({ mod: 'shortcake' }),
+            query,
+            signAssertion: config.signPasskeyAssertion,
+            getCreds: () => authState.creds,
+            updateCreds: patch => ev.emit('creds.update', patch),
+            deviceType: undefined, // default: CHROME
+            emitVerificationCode: code => logger.info({ code }, 'shortcake verification code'),
+            emitPrologueSent: () => ev.emit('connection.update', { passkeyRequired: { hasSigner: true } })
+        })
+        : null;
     const msgRetryCache = config.msgRetryCounterCache ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
@@ -384,7 +398,7 @@ export const makeMessagesRecvSocket = (config) => {
         };
         await query(stanza);
     };
-    const sendRetryRequest = async (node, forceIncludeKeys = false) => {
+    const sendRetryRequest = async (node, forceIncludeKeys = false, decryptionError) => {
         const { fullMessage } = decodeMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '');
         const { key: msgKey } = fullMessage;
         const msgId = msgKey.id;
@@ -420,23 +434,34 @@ export const makeMessagesRecvSocket = (config) => {
         // Check if we should recreate the session
         let shouldRecreateSession = false;
         let recreateReason = '';
-        if (enableAutoSessionRecreation && messageRetryManager && retryCount > 1) {
-            try {
-                // Check if we have a session with this JID
-                const sessionId = signalRepository.jidToSignalProtocolAddress(fromJid);
-                const hasSession = await signalRepository.validateSession(fromJid);
-                const result = messageRetryManager.shouldRecreateSession(fromJid, hasSession.exists);
-                shouldRecreateSession = result.recreate;
-                recreateReason = result.reason;
-                if (shouldRecreateSession) {
-                    logger.debug({ fromJid, retryCount, reason: recreateReason }, 'recreating session for retry');
-                    // Delete existing session to force recreation
-                    await authState.keys.set({ session: { [sessionId]: null } });
-                    forceIncludeKeys = true;
+        const isSessionCorrupted = !!(decryptionError && (decryptionError.toLowerCase().includes('session') ||
+            decryptionError.toLowerCase().includes('key') ||
+            decryptionError.toLowerCase().includes('signature') ||
+            decryptionError.toLowerCase().includes('mac') ||
+            decryptionError.toLowerCase().includes('decrypt')));
+        if (enableAutoSessionRecreation) {
+            if (retryCount > 1 || isSessionCorrupted) {
+                try {
+                    // Check if we have a session with this JID
+                    const sessionId = signalRepository.jidToSignalProtocolAddress(fromJid);
+                    const hasSession = await signalRepository.validateSession(fromJid);
+                    const result = messageRetryManager
+                        ? messageRetryManager.shouldRecreateSession(fromJid, hasSession.exists)
+                        : { recreate: true, reason: 'No messageRetryManager' };
+                    shouldRecreateSession = result.recreate || isSessionCorrupted;
+                    recreateReason = isSessionCorrupted
+                        ? `proactive session repair on decryption error: ${decryptionError}`
+                        : result.reason;
+                    if (shouldRecreateSession) {
+                        logger.debug({ fromJid, retryCount, reason: recreateReason }, 'recreating session for retry');
+                        // Delete existing session to force recreation
+                        await authState.keys.set({ session: { [sessionId]: null } });
+                        forceIncludeKeys = true;
+                    }
+                }
+                catch (error) {
+                    logger.warn({ error, fromJid }, 'failed to check session recreation');
                 }
-            }
-            catch (error) {
-                logger.warn({ error, fromJid }, 'failed to check session recreation');
             }
         }
         if (retryCount <= 2) {
@@ -824,6 +849,30 @@ export const makeMessagesRecvSocket = (config) => {
                     logger.error({ error, node }, 'failed to handle devices notification');
                 }
                 break;
+            case 'passkey_prologue_request':
+                if (shortcakeFlow) {
+                    try {
+                        await shortcakeFlow.handleIncomingNotification(node);
+                    }
+                    catch (error) {
+                        logger.error({ error }, 'error in shortcake passkey prologue');
+                    }
+                }
+                else {
+                    logger.warn('server requested passkey but signPasskeyAssertion is not configured');
+                    ev.emit('connection.update', { passkeyRequired: { hasSigner: false } });
+                }
+                break;
+            case 'crsc_continuation':
+                if (shortcakeFlow) {
+                    try {
+                        await shortcakeFlow.handleIncomingNotification(node);
+                    }
+                    catch (error) {
+                        logger.error({ error }, 'error in shortcake crsc_continuation');
+                    }
+                }
+                break;
             case 'server_sync':
                 const update = getBinaryNodeChild(node, 'collection');
                 if (update) {
@@ -880,9 +929,18 @@ export const makeMessagesRecvSocket = (config) => {
                 break;
             case 'link_code_companion_reg':
                 const linkCodeCompanionReg = getBinaryNodeChild(node, 'link_code_companion_reg');
-                const ref = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_ref'));
-                const primaryIdentityPublicKey = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'primary_identity_pub'));
-                const primaryEphemeralPublicKeyWrapped = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_wrapped_primary_ephemeral_pub'));
+                const refBuffer = getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_ref');
+                const primaryIdentityPublicKeyBuffer = getBinaryNodeChildBuffer(linkCodeCompanionReg, 'primary_identity_pub');
+                const primaryEphemeralPublicKeyWrappedBuffer = getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_wrapped_primary_ephemeral_pub');
+                if (refBuffer === undefined ||
+                    primaryIdentityPublicKeyBuffer === undefined ||
+                    primaryEphemeralPublicKeyWrappedBuffer === undefined) {
+                    logger.debug({ id: node.attrs.id, type: node.attrs.type }, 'skipping empty link code companion registration');
+                    break;
+                }
+                const ref = toRequiredBuffer(refBuffer);
+                const primaryIdentityPublicKey = toRequiredBuffer(primaryIdentityPublicKeyBuffer);
+                const primaryEphemeralPublicKeyWrapped = toRequiredBuffer(primaryEphemeralPublicKeyWrappedBuffer);
                 const codePairingPublicKey = await decipherLinkPublicKey(primaryEphemeralPublicKeyWrapped);
                 const companionSharedKey = Curve.sharedKey(authState.creds.pairingEphemeralKeyPair.private, codePairingPublicKey);
                 const random = randomBytes(32);
@@ -1265,12 +1323,6 @@ export const makeMessagesRecvSocket = (config) => {
     };
     const handleMessage = async (node) => {
         const encNode = getBinaryNodeChild(node, 'enc');
-        // TODO: temporary fix for crashes and issues resulting of failed msmsg decryption
-        if (encNode?.attrs.type === 'msmsg') {
-            logger.debug({ key: node.attrs.key }, 'ignored msmsg');
-            await sendMessageAck(node, NACK_REASONS.MissingMessageSecret);
-            return;
-        }
         let acked = false;
         try {
             const { fullMessage: msg, category, author, decrypt } = decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger);
@@ -1376,7 +1428,7 @@ export const makeMessagesRecvSocket = (config) => {
                                     return;
                                 }
                                 const encNode = getBinaryNodeChild(node, 'enc');
-                                await sendRetryRequest(node, !encNode);
+                                await sendRetryRequest(node, !encNode, msg.messageStubParameters?.[0]);
                                 if (retryRequestDelayMs) {
                                     await delay(retryRequestDelayMs);
                                 }
@@ -1491,8 +1543,45 @@ export const makeMessagesRecvSocket = (config) => {
             await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack call'));
         }
     };
+    const handleLidRefreshAck = async (attrs) => {
+        // NOTE: Yes, it is a string right from the WhatsApp x_x
+        const refreshLidTrue = 'true';
+        if (!config.enableLidMigrationSafety || attrs['refresh_lid'] !== refreshLidTrue)
+            return;
+        const oldLid = attrs.from || attrs.remoteJid;
+        if (!oldLid || (!isLidUser(oldLid) && !isHostedLidUser(oldLid))) {
+            logger.warn({ attrs }, `received 'refresh_lid' ack without a LID sender`);
+            return;
+        }
+        let pn;
+        let newLid;
+        try {
+            pn = (await signalRepository.lidMapping.getPNForLID(oldLid)) || undefined;
+            if (pn && config.refreshMappingOnLidMigration) {
+                const refreshedLid = await signalRepository.lidMapping.getLIDForPN(pn, { force: true });
+                if (refreshedLid && !areJidsSameUser(refreshedLid, oldLid)) {
+                    newLid = refreshedLid;
+                    await signalRepository
+                        .migrateSession(pn, newLid)
+                        .catch(err => logger.warn({ err, pn, oldLid, newLid }, `failed to migrate Signal session after 'refresh_lid' ack`));
+                }
+            }
+        }
+        catch (err) {
+            logger.warn({ err, oldLid }, `failed to refresh LID mapping after 'refresh_lid' ack`);
+        }
+        const migration = {
+            oldLid,
+            reason: 'ack-refresh-lid',
+            pn,
+            newLid,
+            messageId: attrs.id,
+        };
+        ev.emit('lid-migration.update', migration);
+    };
     const handleBadAck = async ({ attrs }) => {
         const key = { remoteJid: attrs.from, fromMe: true, id: attrs.id };
+        await handleLidRefreshAck(attrs);
         // WARNING: REFRAIN FROM ENABLING THIS FOR NOW. IT WILL CAUSE A LOOP
         // // current hypothesis is that if pash is sent in the ack
         // // it means -- the message hasn't reached all devices yet