slidge-whatsapp 0.2.6__cp313-cp313-manylinux_2_36_aarch64.whl → 0.3.0b0__cp313-cp313-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/message.go

@@ -16,6 +16,7 @@ import (
 	"fmt"
 	"io"
 	"runtime/debug"
+	"strconv"
 	"time"
 
 	"github.com/rs/zerolog"
@@ -30,6 +31,7 @@ import (
 	waBinary "go.mau.fi/whatsmeow/binary"
 	"go.mau.fi/whatsmeow/proto/waE2E"
 	"go.mau.fi/whatsmeow/proto/waHistorySync"
+	"go.mau.fi/whatsmeow/proto/waLidMigrationSyncPayload"
 	"go.mau.fi/whatsmeow/proto/waWeb"
 	"go.mau.fi/whatsmeow/store"
 	"go.mau.fi/whatsmeow/types"
@@ -39,7 +41,7 @@ import (
 var pbSerializer = store.SignalProtobufSerializer
 
 func (cli *Client) handleEncryptedMessage(node *waBinary.Node) {
-	ctx := context.TODO()
+	ctx := cli.BackgroundEventCtx
 	info, err := cli.parseMessageInfo(node)
 	if err != nil {
 		cli.Log.Warnf("Failed to parse message: %v", err)
@@ -50,23 +52,24 @@ func (cli *Client) handleEncryptedMessage(node *waBinary.Node) {
 			cli.StoreLIDPNMapping(ctx, info.RecipientAlt, info.Chat)
 		}
 		if info.VerifiedName != nil && len(info.VerifiedName.Details.GetVerifiedName()) > 0 {
-			go cli.updateBusinessName(context.WithoutCancel(ctx), info.Sender, info, info.VerifiedName.Details.GetVerifiedName())
+			go cli.updateBusinessName(cli.BackgroundEventCtx, info.Sender, info, info.VerifiedName.Details.GetVerifiedName())
 		}
-		if len(info.PushName) > 0 && info.PushName != "-" {
-			go cli.updatePushName(context.WithoutCancel(ctx), info.Sender, info, info.PushName)
+		if len(info.PushName) > 0 && info.PushName != "-" && (cli.MessengerConfig == nil || info.PushName != "username") {
+			go cli.updatePushName(cli.BackgroundEventCtx, info.Sender, info, info.PushName)
 		}
-		defer cli.maybeDeferredAck(node)()
+		var cancelled bool
+		defer cli.maybeDeferredAck(ctx, node)(&cancelled)
 		if info.Sender.Server == types.NewsletterServer {
-			cli.handlePlaintextMessage(ctx, info, node)
+			cancelled = cli.handlePlaintextMessage(ctx, info, node)
 		} else {
-			cli.decryptMessages(ctx, info, node)
+			cancelled = cli.decryptMessages(ctx, info, node)
 		}
 	}
 }
 
 func (cli *Client) parseMessageSource(node *waBinary.Node, requireParticipant bool) (source types.MessageSource, err error) {
 	clientID := cli.getOwnID()
-	clientLID := cli.Store.GetLID()
+	clientLID := cli.getOwnLID()
 	if clientID.IsEmpty() {
 		err = ErrNotLoggedIn
 		return
@@ -106,8 +109,8 @@ func (cli *Client) parseMessageSource(node *waBinary.Node, requireParticipant bo
 		} else {
 			source.Chat = from.ToNonAD()
 		}
-		if source.AddressingMode == types.AddressingModeLID {
-			source.RecipientAlt = ag.OptionalJIDOrEmpty("peer_recipient_pn") // existence of this field is not confirmed
+		if source.Chat.Server == types.HiddenUserServer {
+			source.RecipientAlt = ag.OptionalJIDOrEmpty("peer_recipient_pn")
 		} else {
 			source.RecipientAlt = ag.OptionalJIDOrEmpty("peer_recipient_lid")
 		}
@@ -124,7 +127,7 @@ func (cli *Client) parseMessageSource(node *waBinary.Node, requireParticipant bo
 	} else {
 		source.Chat = from.ToNonAD()
 		source.Sender = from
-		if source.AddressingMode == types.AddressingModeLID {
+		if source.Sender.Server == types.HiddenUserServer {
 			source.SenderAlt = ag.OptionalJIDOrEmpty("sender_pn")
 		} else {
 			source.SenderAlt = ag.OptionalJIDOrEmpty("sender_lid")
@@ -156,6 +159,7 @@ func (cli *Client) parseMsgMetaInfo(node waBinary.Node) (metaInfo types.MsgMetaI
 	ag := metaNode.AttrGetter()
 	metaInfo.TargetID = types.MessageID(ag.OptionalString("target_id"))
 	metaInfo.TargetSender = ag.OptionalJIDOrEmpty("target_sender_jid")
+	metaInfo.TargetChat = ag.OptionalJIDOrEmpty("target_chat_jid")
 	deprecatedLIDSession, ok := ag.GetBool("deprecated_lid_session", false)
 	if ok {
 		metaInfo.DeprecatedLIDSession = &deprecatedLIDSession
@@ -218,7 +222,7 @@ func (cli *Client) parseMessageInfo(node *waBinary.Node) (*types.MessageInfo, er
 	return &info, nil
 }
 
-func (cli *Client) handlePlaintextMessage(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) {
+func (cli *Client) handlePlaintextMessage(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) (handlerFailed bool) {
 	// TODO edits have an additional <meta msg_edit_t="1696321271735" original_msg_t="1696321248"/> node
 	plaintext, ok := node.GetOptionalChildByTag("plaintext")
 	if !ok {
@@ -249,7 +253,7 @@ func (cli *Client) handlePlaintextMessage(ctx context.Context, info *types.Messa
 			OriginalTS: meta.AttrGetter().UnixTime("original_msg_t"),
 		}
 	}
-	cli.dispatchEvent(evt.UnwrapRaw())
+	return cli.dispatchEvent(evt.UnwrapRaw())
 }
 
 func (cli *Client) migrateSessionStore(ctx context.Context, pn, lid types.JID) {
@@ -259,12 +263,16 @@ func (cli *Client) migrateSessionStore(ctx context.Context, pn, lid types.JID) {
 	}
 }
 
-func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) {
+func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) (handlerFailed bool) {
 	unavailableNode, ok := node.GetOptionalChildByTag("unavailable")
 	if ok && len(node.GetChildrenByTag("enc")) == 0 {
 		uType := events.UnavailableType(unavailableNode.AttrGetter().String("type"))
 		cli.Log.Warnf("Unavailable message %s from %s (type: %q)", info.ID, info.SourceString(), uType)
-		go cli.delayedRequestMessageFromPhone(info)
+		if cli.SynchronousAck {
+			cli.immediateRequestMessageFromPhone(ctx, info)
+		} else {
+			go cli.delayedRequestMessageFromPhone(info)
+		}
 		cli.dispatchEvent(&events.UndecryptableMessage{Info: *info, IsUnavailable: true, UnavailableType: uType})
 		return
 	}
@@ -307,14 +315,12 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 			decrypted, ciphertextHash, err = cli.decryptGroupMsg(ctx, &child, senderEncryptionJID, info.Chat, info.Timestamp)
 		} else if encType == "msmsg" && info.Sender.IsBot() {
 			targetSenderJID := info.MsgMetaInfo.TargetSender
-			messageSecretSenderJID := targetSenderJID
 			if targetSenderJID.User == "" {
 				if info.Sender.Server == types.BotServer {
-					targetSenderJID = cli.Store.GetLID()
+					targetSenderJID = cli.getOwnLID()
 				} else {
 					targetSenderJID = cli.getOwnID()
 				}
-				messageSecretSenderJID = cli.getOwnID()
 			}
 			var decryptMessageID string
 			if info.MsgBotInfo.EditType == types.EditTypeInner || info.MsgBotInfo.EditType == types.EditTypeLast {
@@ -324,7 +330,7 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 			}
 			var msMsg waE2E.MessageSecretMessage
 			var messageSecret []byte
-			if messageSecret, err = cli.Store.MsgSecrets.GetMessageSecret(ctx, info.Chat, messageSecretSenderJID, info.MsgMetaInfo.TargetID); err != nil {
+			if messageSecret, _, err = cli.Store.MsgSecrets.GetMessageSecret(ctx, info.Chat, targetSenderJID, info.MsgMetaInfo.TargetID); err != nil {
 				err = fmt.Errorf("failed to get message secret for %s: %v", info.MsgMetaInfo.TargetID, err)
 			} else if messageSecret == nil {
 				err = fmt.Errorf("message secret for %s not found", info.MsgMetaInfo.TargetID)
@@ -342,12 +348,20 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 			cli.Log.Debugf("Ignoring message %s from %s: %v", info.ID, info.SourceString(), err)
 			return
 		} else if err != nil {
-			cli.Log.Warnf("Error decrypting message from %s: %v", info.SourceString(), err)
+			cli.Log.Warnf("Error decrypting message %s from %s: %v", info.ID, info.SourceString(), err)
+			if ctx.Err() != nil || errors.Is(err, context.Canceled) {
+				handlerFailed = true
+				return
+			}
 			isUnavailable := encType == "skmsg" && !containsDirectMsg && errors.Is(err, signalerror.ErrNoSenderKeyForUser)
 			if encType != "msmsg" {
-				go cli.sendRetryReceipt(context.WithoutCancel(ctx), node, info, isUnavailable)
+				if cli.SynchronousAck {
+					cli.sendRetryReceipt(ctx, node, info, isUnavailable)
+				} else {
+					go cli.sendRetryReceipt(context.WithoutCancel(ctx), node, info, isUnavailable)
+				}
 			}
-			cli.dispatchEvent(&events.UndecryptableMessage{
+			handlerFailed = cli.dispatchEvent(&events.UndecryptableMessage{
 				Info:            *info,
 				IsUnavailable:   isUnavailable,
 				DecryptFailMode: events.DecryptFailMode(ag.OptionalString("decrypt-fail")),
@@ -365,14 +379,17 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 				cli.Log.Warnf("Error unmarshaling decrypted message from %s: %v", info.SourceString(), err)
 				continue
 			}
-			cli.handleDecryptedMessage(ctx, info, &msg, retryCount)
+			handlerFailed = cli.handleDecryptedMessage(ctx, info, &msg, retryCount)
 			handled = true
 		case 3:
-			handled = cli.handleDecryptedArmadillo(ctx, info, decrypted, retryCount)
+			handled, handlerFailed = cli.handleDecryptedArmadillo(ctx, info, decrypted, retryCount)
 		default:
 			cli.Log.Warnf("Unknown version %d in decrypted message from %s", ag.Int("v"), info.SourceString())
 		}
-		if ciphertextHash != nil && cli.EnableDecryptedEventBuffer {
+		if handlerFailed {
+			cli.Log.Warnf("Handler for %s failed", info.ID)
+		}
+		if ciphertextHash != nil && cli.EnableDecryptedEventBuffer && !handlerFailed {
 			// Use the context passed to decryptMessages
 			err = cli.Store.EventBuffer.ClearBufferedEventPlaintext(ctx, *ciphertextHash)
 			if err != nil {
@@ -385,7 +402,7 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 					Msg("Deleted event plaintext from buffer")
 			}
 
-			if time.Since(cli.lastDecryptedBufferClear) > 12*time.Hour {
+			if time.Since(cli.lastDecryptedBufferClear) > 12*time.Hour && ctx.Err() == nil {
 				cli.lastDecryptedBufferClear = time.Now()
 				go func() {
 					err := cli.Store.EventBuffer.DeleteOldBufferedHashes(context.WithoutCancel(ctx))
@@ -396,9 +413,10 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 			}
 		}
 	}
-	if handled {
+	if handled && !handlerFailed {
 		go cli.sendMessageReceipt(info)
 	}
+	return
 }
 
 func (cli *Client) clearUntrustedIdentity(ctx context.Context, target types.JID) error {
@@ -605,32 +623,52 @@ func (cli *Client) handleHistorySyncNotificationLoop() {
 			go cli.handleHistorySyncNotificationLoop()
 		}
 	}()
-	ctx := context.TODO()
+	ctx := cli.BackgroundEventCtx
 	for notif := range cli.historySyncNotifications {
-		cli.handleHistorySyncNotification(ctx, notif)
+		blob, err := cli.DownloadHistorySync(ctx, notif, false)
+		if err != nil {
+			cli.Log.Errorf("Failed to download history sync: %v", err)
+		} else {
+			cli.dispatchEvent(&events.HistorySync{Data: blob})
+		}
 	}
 }
 
-func (cli *Client) handleHistorySyncNotification(ctx context.Context, notif *waE2E.HistorySyncNotification) {
+// DownloadHistorySync will download and parse the history sync blob from the given history sync notification.
+//
+// You only need to call this manually if you set [Client.ManualHistorySyncDownload] to true.
+// By default, whatsmeow will call this automatically and dispatch an [events.HistorySync] with the parsed data.
+func (cli *Client) DownloadHistorySync(ctx context.Context, notif *waE2E.HistorySyncNotification, synchronousStorage bool) (*waHistorySync.HistorySync, error) {
 	var historySync waHistorySync.HistorySync
 	if data, err := cli.Download(ctx, notif); err != nil {
-		cli.Log.Errorf("Failed to download history sync data: %v", err)
+		return nil, fmt.Errorf("failed to download: %w", err)
 	} else if reader, err := zlib.NewReader(bytes.NewReader(data)); err != nil {
-		cli.Log.Errorf("Failed to create zlib reader for history sync data: %v", err)
+		return nil, fmt.Errorf("failed to prepare to decompress: %w", err)
 	} else if rawData, err := io.ReadAll(reader); err != nil {
-		cli.Log.Errorf("Failed to decompress history sync data: %v", err)
+		return nil, fmt.Errorf("failed to decompress: %w", err)
 	} else if err = proto.Unmarshal(rawData, &historySync); err != nil {
-		cli.Log.Errorf("Failed to unmarshal history sync data: %v", err)
+		return nil, fmt.Errorf("failed to unmarshal: %w", err)
 	} else {
-		cli.Log.Debugf("Received history sync (type %s, chunk %d)", historySync.GetSyncType(), historySync.GetChunkOrder())
-		if historySync.GetSyncType() == waHistorySync.HistorySync_PUSH_NAME {
-			go cli.handleHistoricalPushNames(context.WithoutCancel(ctx), historySync.GetPushnames())
-		} else if len(historySync.GetConversations()) > 0 {
-			go cli.storeHistoricalMessageSecrets(context.WithoutCancel(ctx), historySync.GetConversations())
-		}
-		cli.dispatchEvent(&events.HistorySync{
-			Data: &historySync,
-		})
+		cli.Log.Debugf("Received history sync (type %s, chunk %d, progress %d)", historySync.GetSyncType(), historySync.GetChunkOrder(), historySync.GetProgress())
+		doStorage := func(ctx context.Context) {
+			if historySync.GetSyncType() == waHistorySync.HistorySync_PUSH_NAME {
+				cli.handleHistoricalPushNames(ctx, historySync.GetPushnames())
+			} else if len(historySync.GetConversations()) > 0 {
+				cli.storeHistoricalMessageSecrets(ctx, historySync.GetConversations())
+			}
+			if len(historySync.GetPhoneNumberToLidMappings()) > 0 {
+				cli.storeHistoricalPNLIDMappings(ctx, historySync.GetPhoneNumberToLidMappings())
+			}
+			if historySync.GlobalSettings != nil {
+				cli.storeGlobalSettings(ctx, historySync.GlobalSettings)
+			}
+		}
+		if synchronousStorage {
+			doStorage(ctx)
+		} else {
+			go doStorage(context.WithoutCancel(ctx))
+		}
+		return &historySync, nil
 	}
 }
 
@@ -670,10 +708,11 @@ func (cli *Client) handleAppStateSyncKeyShare(ctx context.Context, keys *waE2E.A
 	}
 }
 
-func (cli *Client) handlePlaceholderResendResponse(msg *waE2E.PeerDataOperationRequestResponseMessage) {
+func (cli *Client) handlePlaceholderResendResponse(msg *waE2E.PeerDataOperationRequestResponseMessage) (ok bool) {
 	reqID := msg.GetStanzaID()
 	parts := msg.GetPeerDataOperationResult()
 	cli.Log.Debugf("Handling response to placeholder resend request %s with %d items", reqID, len(parts))
+	ok = true
 	for i, part := range parts {
 		var webMsg waWeb.WebMessageInfo
 		if resp := part.GetPlaceholderMessageResendResponse(); resp == nil {
@@ -684,36 +723,50 @@ func (cli *Client) handlePlaceholderResendResponse(msg *waE2E.PeerDataOperationR
 			cli.Log.Warnf("Failed to parse web message info in item #%d of response to %s: %v", i+1, reqID, err)
 		} else {
 			msgEvt.UnavailableRequestID = reqID
-			cli.dispatchEvent(msgEvt)
+			ok = cli.dispatchEvent(msgEvt) && ok
 		}
 	}
+	return
 }
 
-func (cli *Client) handleProtocolMessage(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message) {
+func (cli *Client) handleProtocolMessage(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message) (ok bool) {
+	ok = true
 	protoMsg := msg.GetProtocolMessage()
 
-	if protoMsg.GetHistorySyncNotification() != nil && info.IsFromMe {
-		cli.historySyncNotifications <- protoMsg.HistorySyncNotification
-		if cli.historySyncHandlerStarted.CompareAndSwap(false, true) {
-			go cli.handleHistorySyncNotificationLoop()
+	if !info.IsFromMe {
+		return
+	}
+
+	if protoMsg.GetHistorySyncNotification() != nil {
+		if !cli.ManualHistorySyncDownload {
+			cli.historySyncNotifications <- protoMsg.HistorySyncNotification
+			if cli.historySyncHandlerStarted.CompareAndSwap(false, true) {
+				go cli.handleHistorySyncNotificationLoop()
+			}
 		}
 		go cli.sendProtocolMessageReceipt(info.ID, types.ReceiptTypeHistorySync)
 	}
 
+	if protoMsg.GetLidMigrationMappingSyncMessage() != nil {
+		cli.storeLIDSyncMessage(ctx, protoMsg.GetLidMigrationMappingSyncMessage().GetEncodedMappingPayload())
+	}
+
 	if protoMsg.GetPeerDataOperationRequestResponseMessage().GetPeerDataOperationRequestType() == waE2E.PeerDataOperationRequestType_PLACEHOLDER_MESSAGE_RESEND {
-		go cli.handlePlaceholderResendResponse(protoMsg.GetPeerDataOperationRequestResponseMessage())
+		ok = cli.handlePlaceholderResendResponse(protoMsg.GetPeerDataOperationRequestResponseMessage()) && ok
 	}
 
-	if protoMsg.GetAppStateSyncKeyShare() != nil && info.IsFromMe {
+	if protoMsg.GetAppStateSyncKeyShare() != nil {
 		go cli.handleAppStateSyncKeyShare(context.WithoutCancel(ctx), protoMsg.AppStateSyncKeyShare)
 	}
 
 	if info.Category == "peer" {
 		go cli.sendProtocolMessageReceipt(info.ID, types.ReceiptTypePeerMsg)
 	}
+	return
 }
 
-func (cli *Client) processProtocolParts(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message) {
+func (cli *Client) processProtocolParts(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message) (ok bool) {
+	ok = true
 	cli.storeMessageSecret(ctx, info, msg)
 	// Hopefully sender key distribution messages and protocol messages can't be inside ephemeral messages
 	if msg.GetDeviceSentMessage().GetMessage() != nil {
@@ -733,8 +786,9 @@ func (cli *Client) processProtocolParts(ctx context.Context, info *types.Message
 	// N.B. Edits are protocol messages, but they're also wrapped inside EditedMessage,
 	// which is only unwrapped after processProtocolParts, so this won't trigger for edits.
 	if msg.GetProtocolMessage() != nil {
-		cli.handleProtocolMessage(ctx, info, msg)
+		ok = cli.handleProtocolMessage(ctx, info, msg) && ok
 	}
+	return
 }
 
 func (cli *Client) storeMessageSecret(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message) {
@@ -816,10 +870,107 @@ func (cli *Client) storeHistoricalMessageSecrets(ctx context.Context, conversati
 	}
 }
 
-func (cli *Client) handleDecryptedMessage(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message, retryCount int) {
-	cli.processProtocolParts(ctx, info, msg)
+func (cli *Client) storeLIDSyncMessage(ctx context.Context, msg []byte) {
+	var decoded waLidMigrationSyncPayload.LIDMigrationMappingSyncPayload
+	err := proto.Unmarshal(msg, &decoded)
+	if err != nil {
+		zerolog.Ctx(ctx).Err(err).Msg("Failed to unmarshal LID migration mapping sync payload")
+		return
+	}
+	if cli.Store.LIDMigrationTimestamp == 0 && decoded.GetChatDbMigrationTimestamp() > 0 {
+		cli.Store.LIDMigrationTimestamp = int64(decoded.GetChatDbMigrationTimestamp())
+		err = cli.Store.Save(ctx)
+		if err != nil {
+			zerolog.Ctx(ctx).Err(err).
+				Int64("lid_migration_timestamp", cli.Store.LIDMigrationTimestamp).
+				Msg("Failed to save chat DB LID migration timestamp")
+		} else {
+			zerolog.Ctx(ctx).Debug().
+				Int64("lid_migration_timestamp", cli.Store.LIDMigrationTimestamp).
+				Msg("Saved chat DB LID migration timestamp")
+		}
+	}
+	lidPairs := make([]store.LIDMapping, len(decoded.PnToLidMappings))
+	for i, mapping := range decoded.PnToLidMappings {
+		lidPairs[i] = store.LIDMapping{
+			LID: types.JID{User: strconv.FormatUint(mapping.GetAssignedLid(), 10), Server: types.HiddenUserServer},
+			PN:  types.JID{User: strconv.FormatUint(mapping.GetPn(), 10), Server: types.DefaultUserServer},
+		}
+	}
+	err = cli.Store.LIDs.PutManyLIDMappings(ctx, lidPairs)
+	if err != nil {
+		zerolog.Ctx(ctx).Err(err).
+			Int("pair_count", len(lidPairs)).
+			Msg("Failed to store phone number to LID mappings from sync message")
+	} else {
+		zerolog.Ctx(ctx).Debug().
+			Int("pair_count", len(lidPairs)).
+			Msg("Stored PN-LID mappings from sync message")
+	}
+}
+
+func (cli *Client) storeGlobalSettings(ctx context.Context, settings *waHistorySync.GlobalSettings) {
+	if cli.Store.LIDMigrationTimestamp == 0 && settings.GetChatDbLidMigrationTimestamp() > 0 {
+		cli.Store.LIDMigrationTimestamp = settings.GetChatDbLidMigrationTimestamp()
+		err := cli.Store.Save(ctx)
+		if err != nil {
+			zerolog.Ctx(ctx).Err(err).
+				Int64("lid_migration_timestamp", cli.Store.LIDMigrationTimestamp).
+				Msg("Failed to save chat DB LID migration timestamp")
+		} else {
+			zerolog.Ctx(ctx).Debug().
+				Int64("lid_migration_timestamp", cli.Store.LIDMigrationTimestamp).
+				Msg("Saved chat DB LID migration timestamp")
+		}
+	}
+}
+
+func (cli *Client) storeHistoricalPNLIDMappings(ctx context.Context, mappings []*waHistorySync.PhoneNumberToLIDMapping) {
+	lidPairs := make([]store.LIDMapping, 0, len(mappings))
+	for _, mapping := range mappings {
+		pn, err := types.ParseJID(mapping.GetPnJID())
+		if err != nil {
+			zerolog.Ctx(ctx).Err(err).
+				Str("pn_jid", mapping.GetPnJID()).
+				Str("lid_jid", mapping.GetLidJID()).
+				Msg("Failed to parse phone number from history sync")
+			continue
+		}
+		if pn.Server == types.LegacyUserServer {
+			pn.Server = types.DefaultUserServer
+		}
+		lid, err := types.ParseJID(mapping.GetLidJID())
+		if err != nil {
+			zerolog.Ctx(ctx).Err(err).
+				Str("pn_jid", mapping.GetPnJID()).
+				Str("lid_jid", mapping.GetLidJID()).
+				Msg("Failed to parse LID from history sync")
+			continue
+		}
+		lidPairs = append(lidPairs, store.LIDMapping{
+			LID: lid,
+			PN:  pn,
+		})
+	}
+	err := cli.Store.LIDs.PutManyLIDMappings(ctx, lidPairs)
+	if err != nil {
+		zerolog.Ctx(ctx).Err(err).
+			Int("pair_count", len(lidPairs)).
+			Msg("Failed to store phone number to LID mappings from history sync")
+	} else {
+		zerolog.Ctx(ctx).Debug().
+			Int("pair_count", len(lidPairs)).
+			Msg("Stored PN-LID mappings from history sync")
+	}
+}
+
+func (cli *Client) handleDecryptedMessage(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message, retryCount int) bool {
+	ok := cli.processProtocolParts(ctx, info, msg)
+	if !ok {
+		return false
+	}
 	evt := &events.Message{Info: *info, RawMessage: msg, RetryCount: retryCount}
-	cli.dispatchEvent(evt.UnwrapRaw())
+	return cli.dispatchEvent(evt.UnwrapRaw())
 }
 
 func (cli *Client) sendProtocolMessageReceipt(id types.MessageID, msgType types.ReceiptType) {

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/msgsecret.go

@@ -98,22 +98,10 @@ func (cli *Client) decryptMsgSecret(ctx context.Context, msg *events.Message, us
 	if err != nil {
 		return nil, err
 	}
-	baseEncKey, err := cli.Store.MsgSecrets.GetMessageSecret(ctx, msg.Info.Chat, origSender, origMsgKey.GetID())
+	baseEncKey, origSender, err := cli.Store.MsgSecrets.GetMessageSecret(ctx, msg.Info.Chat, origSender, origMsgKey.GetID())
 	if err != nil {
 		return nil, fmt.Errorf("failed to get original message secret key: %w", err)
 	}
-	if baseEncKey == nil && origMsgKey.GetFromMe() && origSender.Server == types.HiddenUserServer {
-		origSender, err = cli.Store.LIDs.GetPNForLID(ctx, origSender)
-		if err != nil {
-			return nil, fmt.Errorf("%w (also failed to get PN for LID: %w)", ErrOriginalMessageSecretNotFound, err)
-		} else if origSender.IsEmpty() {
-			return nil, fmt.Errorf("%w (PN for LID not found)", ErrOriginalMessageSecretNotFound)
-		}
-		baseEncKey, err = cli.Store.MsgSecrets.GetMessageSecret(ctx, msg.Info.Chat, origSender, origMsgKey.GetID())
-		if err != nil {
-			return nil, fmt.Errorf("failed to get original message secret key with PN: %w", err)
-		}
-	}
 	if baseEncKey == nil {
 		return nil, ErrOriginalMessageSecretNotFound
 	}
@@ -132,7 +120,7 @@ func (cli *Client) encryptMsgSecret(ctx context.Context, ownID, chat, origSender
 		return nil, nil, ErrNotLoggedIn
 	}
 
-	baseEncKey, err := cli.Store.MsgSecrets.GetMessageSecret(ctx, chat, origSender, origMsgID)
+	baseEncKey, origSender, err := cli.Store.MsgSecrets.GetMessageSecret(ctx, chat, origSender, origMsgID)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to get original message secret key: %w", err)
 	} else if baseEncKey == nil {

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/newsletter.go

@@ -10,10 +10,16 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"log"
 	"strings"
 	"time"
 
+	"github.com/beeper/argo-go/codec"
+	"github.com/beeper/argo-go/pkg/buf"
+
+	"go.mau.fi/whatsmeow/argo"
 	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/proto/waWa6"
 	"go.mau.fi/whatsmeow/types"
 )
 
@@ -118,9 +124,53 @@ const (
 	mutationCreateNewsletter       = "6234210096708695"
 	mutationUnfollowNewsletter     = "6392786840836363"
 	mutationFollowNewsletter       = "9926858900719341"
+
+	// desktop & mobile
+	queryFetchNewsletterDesktop        = "9779843322044422"
+	queryRecommendedNewslettersDesktop = "27256776790637714"
+	querySubscribedNewslettersDesktop  = "8621797084555037"
+	queryNewsletterSubscribersDesktop  = "25403502652570342"
+	mutationMuteNewsletterDesktop      = "5971669009605755" // variables -> {newsletter_id, updates->{description, settings}}, output: xwa2_newsletter_update -> NewsletterMetadata without viewer meta
+	mutationUnmuteNewsletterDesktop    = "6104029483058502"
+	mutationUpdateNewsletterDesktop    = "7839742399440946"
+	mutationCreateNewsletterDesktop    = "27527996220149684"
+	mutationUnfollowNewsletterDesktop  = "8782612271820087"
+	mutationFollowNewsletterDesktop    = "8621797084555037"
 )
 
+func convertQueryID(cli *Client, queryID string) string {
+	if payload := cli.Store.GetClientPayload(); payload.GetUserAgent().Platform == waWa6.ClientPayload_UserAgent_MACOS.Enum() || payload.GetWebInfo() == nil {
+		switch queryID {
+		case queryFetchNewsletter:
+			return queryFetchNewsletterDesktop
+		case queryRecommendedNewsletters:
+			return queryRecommendedNewslettersDesktop
+		case querySubscribedNewsletters:
+			return querySubscribedNewslettersDesktop
+		case queryNewsletterSubscribers:
+			return queryNewsletterSubscribersDesktop
+		case mutationMuteNewsletter:
+			return mutationMuteNewsletterDesktop
+		case mutationUnmuteNewsletter:
+			return mutationUnmuteNewsletterDesktop
+		case mutationUpdateNewsletter:
+			return mutationUpdateNewsletterDesktop
+		case mutationCreateNewsletter:
+			return mutationCreateNewsletterDesktop
+		case mutationUnfollowNewsletter:
+			return mutationUnfollowNewsletterDesktop
+		case mutationFollowNewsletter:
+			return mutationFollowNewsletterDesktop
+		default:
+			return queryID
+		}
+	} else {
+		return queryID
+	}
+}
+
 func (cli *Client) sendMexIQ(ctx context.Context, queryID string, variables any) (json.RawMessage, error) {
+	queryID = convertQueryID(cli, queryID)
 	payload, err := json.Marshal(map[string]any{
 		"variables": variables,
 	})
@@ -151,14 +201,40 @@ func (cli *Client) sendMexIQ(ctx context.Context, queryID string, variables any)
 	if !ok {
 		return nil, fmt.Errorf("unexpected content type %T in mex response", result.Content)
 	}
-	var gqlResp types.GraphQLResponse
-	err = json.Unmarshal(resultContent, &gqlResp)
-	if err != nil {
-		return nil, fmt.Errorf("failed to unmarshal graphql response: %w", err)
-	} else if len(gqlResp.Errors) > 0 {
-		return gqlResp.Data, fmt.Errorf("graphql error: %w", gqlResp.Errors)
+	if result.AttrGetter().OptionalString("format") == "argo" {
+		store, err := argo.GetStore()
+		if err != nil {
+			return nil, err
+		}
+		queryIDMap, err := argo.GetQueryIDToMessageName()
+		if err != nil {
+			return nil, err
+		}
+		wt := store[queryIDMap[queryID]]
+
+		decoder, err := codec.NewArgoDecoder(buf.NewBufReadonly(resultContent))
+		if err != nil {
+			return nil, err
+		}
+		data, err := decoder.ArgoToMap(wt)
+		if err != nil {
+			log.Fatalf("argo to map error: %v", err)
+		}
+		b, err := json.Marshal(data)
+		if err != nil {
+			return nil, err
+		}
+		return b, nil
+	} else {
+		var gqlResp types.GraphQLResponse
+		err = json.Unmarshal(resultContent, &gqlResp)
+		if err != nil {
+			return nil, fmt.Errorf("failed to unmarshal graphql response: %w", err)
+		} else if len(gqlResp.Errors) > 0 {
+			return gqlResp.Data, fmt.Errorf("graphql error: %w", gqlResp.Errors)
+		}
+		return gqlResp.Data, nil
 	}
-	return gqlResp.Data, nil
 }
 
 type respGetNewsletterInfo struct {