fix: decrypt poll votes across PN and LID parent authors

.gitignore

@@ -15,4 +15,4 @@ bench-profiles-*/
 /test/
 .claude
 *.log
-___*
+___*

src/client/coordinators/WaMessageCoordinator.ts

@@ -28,13 +28,14 @@ import { MEDIA_UPLOAD_PATHS } from '@media/constants'
 import type { WaMediaTransferClient } from '@media/transfer/WaMediaTransferClient'
 import type { MediaKind } from '@media/types'
 import {
-    buildAddonAdditionalData,
+    buildAddonSenderPairs,
+    collectUniqueUserJids,
     decodeAddonPlaintext,
-    decryptAddonPayload,
+    decryptAddonPayloadWithSenderFallback,
     identifyEncryptedAddon,
+    resolveAddonParentSenderFromKey,
     resolveParentMessageSecret,
-    resolvePollOptionNames,
-    shouldUseAddonAdditionalData
+    resolvePollOptionNames
 } from '@message/crypto/addon-crypto'
 import { unwrapMessage } from '@message/encode/content'
 import { encodeGroupHistoryBundle } from '@message/kinds/group-history'
@@ -848,20 +849,40 @@ export class WaMessageCoordinator {
             return
         }
 
-        const parentMsgOriginalSender = parentEntry.senderJid
-        const modificationSender = event.key.participant ?? event.key.remoteJid
+        const modificationSenderRaw = event.key.participant ?? event.key.remoteJid
+        if (!modificationSenderRaw) return
+
+        const modificationSenderCandidates = collectUniqueUserJids(
+            event.key.fromMe ? event.rawNode.attrs.from : undefined,
+            modificationSenderRaw,
+            event.key.participantAlt,
+            event.key.remoteJidAlt,
+            event.rawNode.attrs.participant_pn,
+            event.rawNode.attrs.sender_pn,
+            event.rawNode.attrs.participant,
+            event.key.isGroup ? undefined : event.rawNode.attrs.from
+        )
+
+        const keyParentSender = resolveAddonParentSenderFromKey(
+            addon.targetMessageKey,
+            event.key.isGroup
+        )
+        const parentMsgOriginalSenderCandidates = collectUniqueUserJids(
+            keyParentSender,
+            parentEntry.senderJid
+        )
+        const senderPairs = buildAddonSenderPairs({
+            parentCandidates: parentMsgOriginalSenderCandidates,
+            modificationCandidates: modificationSenderCandidates
+        })
 
-        const plaintext = await decryptAddonPayload({
+        const plaintext = await decryptAddonPayloadWithSenderFallback({
             messageSecret: parentEntry.secret,
             stanzaId: targetMessageId,
-            parentMsgOriginalSender,
-            modificationSender,
+            senderPairs,
             modificationType: addon.modificationType,
             ciphertext: addon.encPayload,
-            iv: addon.encIv,
-            additionalData: shouldUseAddonAdditionalData(addon.modificationType)
-                ? buildAddonAdditionalData(targetMessageId, modificationSender)
-                : undefined
+            iv: addon.encIv
         })
 
         let decrypted = decodeAddonPlaintext(addon.kind, plaintext)

src/client/coordinators/WaMessageDispatchCoordinator.ts

@@ -600,9 +600,11 @@ export class WaMessageDispatchCoordinator {
             sendOptions.id &&
             (this.deps.persistAllMessageSecrets || needsSecretPersistence(messageWithSecret))
         ) {
-            const meJid = this.deps.getCurrentCredentials()?.meJid ?? ''
             void this.deps.messageSecretStore
-                .set(sendOptions.id, { secret: rawSecret, senderJid: meJid })
+                .set(sendOptions.id, {
+                    secret: rawSecret,
+                    senderJid: this.resolveOutgoingSecretSenderJid()
+                })
                 .catch((error) => {
                     this.deps.logger.warn('failed to persist outgoing message secret', {
                         id: sendOptions.id,
@@ -1480,6 +1482,40 @@ export class WaMessageDispatchCoordinator {
         return WA_ADDRESSING_MODES.PN
     }
 
+    /**
+     * Parent-author JID stored with the outgoing message secret. Peers address
+     * us by LID in `pollCreationMessageKey` during the PN→LID migration, so a
+     * valid `meLid` wins. A malformed LID must not abort the send: fall back to
+     * a normalized `meJid`, then to the empty sender (same recoverable path as
+     * {@link resolveSenderForAddressingMode}).
+     */
+    private resolveOutgoingSecretSenderJid(): string {
+        const credentials = this.deps.getCurrentCredentials()
+        const meLid = credentials?.meLid
+        if (meLid && meLid.includes('@')) {
+            try {
+                return toUserJid(meLid)
+            } catch (error) {
+                this.deps.logger.trace('ignoring malformed me lid jid', {
+                    meLid,
+                    message: toError(error).message
+                })
+            }
+        }
+        const meJid = credentials?.meJid
+        if (meJid && meJid.includes('@')) {
+            try {
+                return toUserJid(meJid)
+            } catch (error) {
+                this.deps.logger.trace('ignoring malformed me jid', {
+                    meJid,
+                    message: toError(error).message
+                })
+            }
+        }
+        return ''
+    }
+
     private resolveSenderForAddressingMode(
         addressingMode: GroupAddressingMode,
         meJid: string

src/client/coordinators/__tests__/coordinators.test.ts

@@ -134,6 +134,7 @@ function createMessageDispatchCoordinator(
     groupMetadataStore: WaGroupMetadataMemoryStore,
     overrides?: {
         readonly meJid?: string
+        readonly meLid?: string
         readonly mobileMessageIdFormat?: () => boolean
         readonly serverClock?: ServerClock
         readonly signalDeviceSync?: {
@@ -177,7 +178,9 @@ function createMessageDispatchCoordinator(
             set: async (_id: string, _entry: { secret: Uint8Array; senderJid: string }) => {}
         } as never,
         getCurrentCredentials: () =>
-            overrides?.meJid ? ({ meJid: overrides.meJid } as never) : null,
+            overrides?.meJid || overrides?.meLid
+                ? ({ meJid: overrides.meJid, meLid: overrides.meLid } as never)
+                : null,
         resolvePrivacyTokenNode: async () => null,
         onDirectMessageSent: () => undefined,
         mobileMessageIdFormat: overrides?.mobileMessageIdFormat,
@@ -201,6 +204,14 @@ function buildAppStateSyncResult(
     return { collections }
 }
 
+function callResolveOutgoingSecretSenderJid(coordinator: WaMessageDispatchCoordinator): string {
+    return (
+        coordinator as unknown as {
+            resolveOutgoingSecretSenderJid(): string
+        }
+    ).resolveOutgoingSecretSenderJid()
+}
+
 function callResolvePeerRecipientPn(
     coordinator: WaMessageDispatchCoordinator,
     recipientUserJid: string,
@@ -229,6 +240,36 @@ test('message dispatch emits message_send with the outbound proto and destinatio
     assert.ok(events[0]?.message)
 })
 
+test('outgoing secret sender prefers meLid and recedes to meJid when lid is malformed', () => {
+    const store = new WaGroupMetadataMemoryStore()
+    const withLid = createMessageDispatchCoordinator(store, {
+        meJid: '5511000000000:12@s.whatsapp.net',
+        meLid: '123456789:3@lid'
+    })
+    assert.equal(callResolveOutgoingSecretSenderJid(withLid), '123456789@lid')
+
+    const malformedLid = createMessageDispatchCoordinator(store, {
+        meJid: '5511000000000:12@s.whatsapp.net',
+        meLid: 'not-a-jid'
+    })
+    assert.equal(callResolveOutgoingSecretSenderJid(malformedLid), '5511000000000@s.whatsapp.net')
+
+    const malformedLidWithAt = createMessageDispatchCoordinator(store, {
+        meJid: '5511000000000@s.whatsapp.net',
+        meLid: '@lid'
+    })
+    assert.equal(
+        callResolveOutgoingSecretSenderJid(malformedLidWithAt),
+        '5511000000000@s.whatsapp.net'
+    )
+
+    const bothMalformed = createMessageDispatchCoordinator(store, {
+        meJid: 'not-a-jid',
+        meLid: 'also-bad'
+    })
+    assert.equal(callResolveOutgoingSecretSenderJid(bothMalformed), '')
+})
+
 test('resolvePeerRecipientPn: a PN-addressed caller on a LID envelope stamps that PN', async () => {
     const coordinator = createMessageDispatchCoordinator(new WaGroupMetadataMemoryStore())
     const pn = await callResolvePeerRecipientPn(