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

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

@@ -39,6 +39,11 @@ type ReqCreateGroup struct {
 	// A create key can be provided to deduplicate the group create notification that will be triggered
 	// when the group is created. If provided, the JoinedGroup event will contain the same key.
 	CreateKey types.MessageID
+
+	types.GroupEphemeral
+	types.GroupAnnounce
+	types.GroupLocked
+	types.GroupMembershipApprovalMode
 	// Set IsParent to true to create a community instead of a normal group.
 	// When creating a community, the linked announcement group will be created automatically by the server.
 	types.GroupParent
@@ -49,13 +54,22 @@ type ReqCreateGroup struct {
 // CreateGroup creates a group on WhatsApp with the given name and participants.
 //
 // See ReqCreateGroup for parameters.
-func (cli *Client) CreateGroup(req ReqCreateGroup) (*types.GroupInfo, error) {
+func (cli *Client) CreateGroup(ctx context.Context, req ReqCreateGroup) (*types.GroupInfo, error) {
 	participantNodes := make([]waBinary.Node, len(req.Participants), len(req.Participants)+1)
 	for i, participant := range req.Participants {
 		participantNodes[i] = waBinary.Node{
 			Tag:   "participant",
 			Attrs: waBinary.Attrs{"jid": participant},
 		}
+		pt, err := cli.Store.PrivacyTokens.GetPrivacyToken(ctx, participant)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get privacy token for participant %s: %v", participant, err)
+		} else if pt != nil {
+			participantNodes[i].Content = []waBinary.Node{{
+				Tag:     "privacy",
+				Content: pt.Token,
+			}}
+		}
 	}
 	if req.CreateKey == "" {
 		req.CreateKey = cli.GenerateMessageID()
@@ -76,9 +90,33 @@ func (cli *Client) CreateGroup(req ReqCreateGroup) (*types.GroupInfo, error) {
 			Attrs: waBinary.Attrs{"jid": req.LinkedParentJID},
 		})
 	}
+	if req.IsLocked {
+		participantNodes = append(participantNodes, waBinary.Node{Tag: "locked"})
+	}
+	if req.IsAnnounce {
+		participantNodes = append(participantNodes, waBinary.Node{Tag: "announcement"})
+	}
+	if req.IsEphemeral {
+		participantNodes = append(participantNodes, waBinary.Node{
+			Tag: "ephemeral",
+			Attrs: waBinary.Attrs{
+				"expiration": req.DisappearingTimer,
+				"trigger":    "1", // TODO what's this?
+			},
+		})
+	}
+	if req.IsJoinApprovalRequired {
+		participantNodes = append(participantNodes, waBinary.Node{
+			Tag: "membership_approval_mode",
+			Content: []waBinary.Node{{
+				Tag:   "group_join",
+				Attrs: waBinary.Attrs{"state": "on"},
+			}},
+		})
+	}
 	// WhatsApp web doesn't seem to include the static prefix for these
 	key := strings.TrimPrefix(req.CreateKey, "3EB0")
-	resp, err := cli.sendGroupIQ(context.TODO(), iqSet, types.GroupServerJID, waBinary.Node{
+	resp, err := cli.sendGroupIQ(ctx, iqSet, types.GroupServerJID, waBinary.Node{
 		Tag: "create",
 		Attrs: waBinary.Attrs{
 			"subject": req.Name,
@@ -519,7 +557,14 @@ func (cli *Client) GetLinkedGroupsParticipants(community types.JID) ([]types.JID
 	if !ok {
 		return nil, &ElementMissingError{Tag: "linked_groups_participants", In: "response to community participants query"}
 	}
-	return parseParticipantList(&participants), nil
+	members, lidPairs := parseParticipantList(&participants)
+	if len(lidPairs) > 0 {
+		err = cli.Store.LIDs.PutManyLIDMappings(context.TODO(), lidPairs)
+		if err != nil {
+			cli.Log.Warnf("Failed to store LID mappings for community participants: %v", err)
+		}
+	}
+	return members, nil
 }
 
 // GetGroupInfo requests basic info about a group chat from the WhatsApp servers.
@@ -702,7 +747,7 @@ func parseGroupLinkTargetNode(groupNode *waBinary.Node) (types.GroupLinkTarget,
 	}, ag.Error()
 }
 
-func parseParticipantList(node *waBinary.Node) (participants []types.JID) {
+func parseParticipantList(node *waBinary.Node) (participants []types.JID, lidPairs []store.LIDMapping) {
 	children := node.GetChildren()
 	participants = make([]types.JID, 0, len(children))
 	for _, child := range children {
@@ -711,14 +756,31 @@ func parseParticipantList(node *waBinary.Node) (participants []types.JID) {
 			continue
 		}
 		participants = append(participants, jid)
+		if jid.Server == types.HiddenUserServer {
+			phoneNumber, ok := child.Attrs["phone_number"].(types.JID)
+			if ok && !phoneNumber.IsEmpty() {
+				lidPairs = append(lidPairs, store.LIDMapping{
+					LID: jid,
+					PN:  phoneNumber,
+				})
+			}
+		} else if jid.Server == types.DefaultUserServer {
+			lid, ok := child.Attrs["lid"].(types.JID)
+			if ok && !lid.IsEmpty() {
+				lidPairs = append(lidPairs, store.LIDMapping{
+					LID: lid,
+					PN:  jid,
+				})
+			}
+		}
 	}
 	return
 }
 
-func (cli *Client) parseGroupCreate(parentNode, node *waBinary.Node) (*events.JoinedGroup, error) {
+func (cli *Client) parseGroupCreate(parentNode, node *waBinary.Node) (*events.JoinedGroup, []store.LIDMapping, error) {
 	groupNode, ok := node.GetOptionalChildByTag("group")
 	if !ok {
-		return nil, fmt.Errorf("group create notification didn't contain group info")
+		return nil, nil, fmt.Errorf("group create notification didn't contain group info")
 	}
 	var evt events.JoinedGroup
 	pag := parentNode.AttrGetter()
@@ -731,13 +793,22 @@ func (cli *Client) parseGroupCreate(parentNode, node *waBinary.Node) (*events.Jo
 	evt.Notify = pag.OptionalString("notify")
 	info, err := cli.parseGroupNode(&groupNode)
 	if err != nil {
-		return nil, fmt.Errorf("failed to parse group info in create notification: %w", err)
+		return nil, nil, fmt.Errorf("failed to parse group info in create notification: %w", err)
 	}
 	evt.GroupInfo = *info
-	return &evt, nil
+	lidPairs := make([]store.LIDMapping, 0, len(info.Participants))
+	for _, pcp := range info.Participants {
+		if !pcp.PhoneNumber.IsEmpty() && !pcp.LID.IsEmpty() {
+			lidPairs = append(lidPairs, store.LIDMapping{
+				LID: pcp.LID,
+				PN:  pcp.PhoneNumber,
+			})
+		}
+	}
+	return &evt, lidPairs, nil
 }
 
-func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, error) {
+func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, []store.LIDMapping, error) {
 	var evt events.GroupInfo
 	ag := node.AttrGetter()
 	evt.JID = ag.JID("from")
@@ -746,9 +817,10 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 	evt.SenderPN = ag.OptionalJID("participant_pn")
 	evt.Timestamp = ag.UnixTime("t")
 	if !ag.OK() {
-		return nil, fmt.Errorf("group change doesn't contain required attributes: %w", ag.Error())
+		return nil, nil, fmt.Errorf("group change doesn't contain required attributes: %w", ag.Error())
 	}
 
+	var lidPairs []store.LIDMapping
 	for _, child := range node.GetChildren() {
 		cag := child.AttrGetter()
 		if child.Tag == "add" || child.Tag == "remove" || child.Tag == "promote" || child.Tag == "demote" {
@@ -758,13 +830,13 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 		switch child.Tag {
 		case "add":
 			evt.JoinReason = cag.OptionalString("reason")
-			evt.Join = parseParticipantList(&child)
+			evt.Join, lidPairs = parseParticipantList(&child)
 		case "remove":
-			evt.Leave = parseParticipantList(&child)
+			evt.Leave, lidPairs = parseParticipantList(&child)
 		case "promote":
-			evt.Promote = parseParticipantList(&child)
+			evt.Promote, lidPairs = parseParticipantList(&child)
 		case "demote":
-			evt.Demote = parseParticipantList(&child)
+			evt.Demote, lidPairs = parseParticipantList(&child)
 		case "locked":
 			evt.Locked = &types.GroupLocked{IsLocked: true}
 		case "unlocked":
@@ -785,7 +857,7 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 				topicChild := child.GetChildByTag("body")
 				topicBytes, ok := topicChild.Content.([]byte)
 				if !ok {
-					return nil, fmt.Errorf("group change description has unexpected body: %s", topicChild.XMLString())
+					return nil, nil, fmt.Errorf("group change description has unexpected body: %s", topicChild.XMLString())
 				}
 				topicStr = string(topicBytes)
 			}
@@ -827,12 +899,12 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 			}
 			groupNode, ok := child.GetOptionalChildByTag("group")
 			if !ok {
-				return nil, &ElementMissingError{Tag: "group", In: "group link"}
+				return nil, nil, &ElementMissingError{Tag: "group", In: "group link"}
 			}
 			var err error
 			evt.Link.Group, err = parseGroupLinkTargetNode(&groupNode)
 			if err != nil {
-				return nil, fmt.Errorf("failed to parse group link node in group change: %w", err)
+				return nil, nil, fmt.Errorf("failed to parse group link node in group change: %w", err)
 			}
 		case "unlink":
 			evt.Unlink = &types.GroupLinkChange{
@@ -841,12 +913,12 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 			}
 			groupNode, ok := child.GetOptionalChildByTag("group")
 			if !ok {
-				return nil, &ElementMissingError{Tag: "group", In: "group unlink"}
+				return nil, nil, &ElementMissingError{Tag: "group", In: "group unlink"}
 			}
 			var err error
 			evt.Unlink.Group, err = parseGroupLinkTargetNode(&groupNode)
 			if err != nil {
-				return nil, fmt.Errorf("failed to parse group unlink node in group change: %w", err)
+				return nil, nil, fmt.Errorf("failed to parse group unlink node in group change: %w", err)
 			}
 		case "membership_approval_mode":
 			evt.MembershipApprovalMode = &types.GroupMembershipApprovalMode{
@@ -856,10 +928,10 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 			evt.UnknownChanges = append(evt.UnknownChanges, &child)
 		}
 		if !cag.OK() {
-			return nil, fmt.Errorf("group change %s element doesn't contain required attributes: %w", child.Tag, cag.Error())
+			return nil, nil, fmt.Errorf("group change %s element doesn't contain required attributes: %w", child.Tag, cag.Error())
 		}
 	}
-	return &evt, nil
+	return &evt, lidPairs, nil
 }
 
 func (cli *Client) updateGroupParticipantCache(evt *events.GroupInfo) {
@@ -893,17 +965,17 @@ Outer:
 	}
 }
 
-func (cli *Client) parseGroupNotification(node *waBinary.Node) (any, error) {
+func (cli *Client) parseGroupNotification(node *waBinary.Node) (any, []store.LIDMapping, error) {
 	children := node.GetChildren()
 	if len(children) == 1 && children[0].Tag == "create" {
 		return cli.parseGroupCreate(node, &children[0])
 	} else {
-		groupChange, err := cli.parseGroupChange(node)
+		groupChange, lidPairs, err := cli.parseGroupChange(node)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		cli.updateGroupParticipantCache(groupChange)
-		return groupChange, nil
+		return groupChange, lidPairs, nil
 	}
 }
 

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

@@ -219,11 +219,11 @@ func (int *DangerousInternalClient) ParseGroupNode(groupNode *waBinary.Node) (*t
 	return int.c.parseGroupNode(groupNode)
 }
 
-func (int *DangerousInternalClient) ParseGroupCreate(parentNode, node *waBinary.Node) (*events.JoinedGroup, error) {
+func (int *DangerousInternalClient) ParseGroupCreate(parentNode, node *waBinary.Node) (*events.JoinedGroup, []store.LIDMapping, error) {
 	return int.c.parseGroupCreate(parentNode, node)
 }
 
-func (int *DangerousInternalClient) ParseGroupChange(node *waBinary.Node) (*events.GroupInfo, error) {
+func (int *DangerousInternalClient) ParseGroupChange(node *waBinary.Node) (*events.GroupInfo, []store.LIDMapping, error) {
 	return int.c.parseGroupChange(node)
 }
 
@@ -231,7 +231,7 @@ func (int *DangerousInternalClient) UpdateGroupParticipantCache(evt *events.Grou
 	int.c.updateGroupParticipantCache(evt)
 }
 
-func (int *DangerousInternalClient) ParseGroupNotification(node *waBinary.Node) (any, error) {
+func (int *DangerousInternalClient) ParseGroupNotification(node *waBinary.Node) (any, []store.LIDMapping, error) {
 	return int.c.parseGroupNotification(node)
 }
 
@@ -279,7 +279,7 @@ func (int *DangerousInternalClient) ParseMessageInfo(node *waBinary.Node) (*type
 	return int.c.parseMessageInfo(node)
 }
 
-func (int *DangerousInternalClient) HandlePlaintextMessage(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) bool {
+func (int *DangerousInternalClient) HandlePlaintextMessage(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) (handlerFailed bool) {
 	return int.c.handlePlaintextMessage(ctx, info, node)
 }
 
@@ -319,16 +319,16 @@ func (int *DangerousInternalClient) HandleAppStateSyncKeyShare(ctx context.Conte
 	int.c.handleAppStateSyncKeyShare(ctx, keys)
 }
 
-func (int *DangerousInternalClient) HandlePlaceholderResendResponse(msg *waE2E.PeerDataOperationRequestResponseMessage) {
-	int.c.handlePlaceholderResendResponse(msg)
+func (int *DangerousInternalClient) HandlePlaceholderResendResponse(msg *waE2E.PeerDataOperationRequestResponseMessage) (ok bool) {
+	return int.c.handlePlaceholderResendResponse(msg)
 }
 
-func (int *DangerousInternalClient) HandleProtocolMessage(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message) {
-	int.c.handleProtocolMessage(ctx, info, msg)
+func (int *DangerousInternalClient) HandleProtocolMessage(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message) (ok bool) {
+	return int.c.handleProtocolMessage(ctx, info, msg)
 }
 
-func (int *DangerousInternalClient) ProcessProtocolParts(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message) {
-	int.c.processProtocolParts(ctx, info, msg)
+func (int *DangerousInternalClient) ProcessProtocolParts(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message) (ok bool) {
+	return int.c.processProtocolParts(ctx, info, msg)
 }
 
 func (int *DangerousInternalClient) StoreMessageSecret(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message) {
@@ -339,6 +339,18 @@ func (int *DangerousInternalClient) StoreHistoricalMessageSecrets(ctx context.Co
 	int.c.storeHistoricalMessageSecrets(ctx, conversations)
 }
 
+func (int *DangerousInternalClient) StoreLIDSyncMessage(ctx context.Context, msg []byte) {
+	int.c.storeLIDSyncMessage(ctx, msg)
+}
+
+func (int *DangerousInternalClient) StoreGlobalSettings(ctx context.Context, settings *waHistorySync.GlobalSettings) {
+	int.c.storeGlobalSettings(ctx, settings)
+}
+
+func (int *DangerousInternalClient) StoreHistoricalPNLIDMappings(ctx context.Context, mappings []*waHistorySync.PhoneNumberToLIDMapping) {
+	int.c.storeHistoricalPNLIDMappings(ctx, mappings)
+}
+
 func (int *DangerousInternalClient) HandleDecryptedMessage(ctx context.Context, info *types.MessageInfo, msg *waE2E.Message, retryCount int) bool {
 	return int.c.handleDecryptedMessage(ctx, info, msg, retryCount)
 }

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

@@ -69,7 +69,7 @@ func (cli *Client) handleEncryptedMessage(node *waBinary.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
@@ -315,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 {
@@ -332,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)
@@ -351,7 +349,7 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 			return
 		} else if err != nil {
 			cli.Log.Warnf("Error decrypting message %s from %s: %v", info.ID, info.SourceString(), err)
-			if ctx.Err() != nil {
+			if ctx.Err() != nil || errors.Is(err, context.Canceled) {
 				handlerFailed = true
 				return
 			}
@@ -388,7 +386,10 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 		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 {
@@ -412,7 +413,7 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 			}
 		}
 	}
-	if handled {
+	if handled && !handlerFailed {
 		go cli.sendMessageReceipt(info)
 	}
 	return
@@ -648,7 +649,7 @@ func (cli *Client) DownloadHistorySync(ctx context.Context, notif *waE2E.History
 	} else if err = proto.Unmarshal(rawData, &historySync); err != nil {
 		return nil, fmt.Errorf("failed to unmarshal: %w", err)
 	} else {
-		cli.Log.Debugf("Received history sync (type %s, chunk %d)", historySync.GetSyncType(), historySync.GetChunkOrder())
+		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())

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 {

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

@@ -430,10 +430,14 @@ func (cli *Client) handleNotification(node *waBinary.Node) {
 	case "fbid:devices":
 		cli.handleFBDeviceNotification(ctx, node)
 	case "w:gp2":
-		evt, err := cli.parseGroupNotification(node)
+		evt, lidPairs, err := cli.parseGroupNotification(node)
 		if err != nil {
 			cli.Log.Errorf("Failed to parse group notification: %v", err)
 		} else {
+			err = cli.Store.LIDs.PutManyLIDMappings(ctx, lidPairs)
+			if err != nil {
+				cli.Log.Errorf("Failed to store LID mappings from group notification: %v", err)
+			}
 			cancelled = cli.dispatchEvent(evt)
 		}
 	case "picture":

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/pair-code.go

@@ -94,9 +94,9 @@ func (cli *Client) PairPhone(ctx context.Context, phone string, showPushNotifica
 	ephemeralKeyPair, ephemeralKey, encodedLinkingCode := generateCompanionEphemeralKey()
 	phone = notNumbers.ReplaceAllString(phone, "")
 	if len(phone) <= 6 {
-		return "", fmt.Errorf("phone number too short")
+		return "", ErrPhoneNumberTooShort
 	} else if strings.HasPrefix(phone, "0") {
-		return "", fmt.Errorf("international phone number required (must not start with 0)")
+		return "", ErrPhoneNumberIsNotInternational
 	}
 	jid := types.NewJID(phone, types.DefaultUserServer)
 	resp, err := cli.sendIQ(infoQuery{

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

@@ -62,7 +62,9 @@ func (cli *Client) handlePresence(node *waBinary.Node) {
 // You should call this at least once after connecting so that the server has your pushname.
 // Otherwise, other users will see "-" as the name.
 func (cli *Client) SendPresence(state types.Presence) error {
-	if len(cli.Store.PushName) == 0 {
+	if cli == nil {
+		return ErrClientIsNil
+	} else if len(cli.Store.PushName) == 0 && cli.MessengerConfig == nil {
 		return ErrNoPushName
 	}
 	if state == types.PresenceAvailable {
@@ -70,12 +72,16 @@ func (cli *Client) SendPresence(state types.Presence) error {
 	} else {
 		cli.sendActiveReceipts.CompareAndSwap(1, 0)
 	}
+	attrs := waBinary.Attrs{
+		"type": string(state),
+	}
+	// PushName not set when using WhatsApp for Messenger E2EE
+	if cli.MessengerConfig == nil {
+		attrs["name"] = cli.Store.PushName
+	}
 	return cli.sendNode(waBinary.Node{
-		Tag: "presence",
-		Attrs: waBinary.Attrs{
-			"name": cli.Store.PushName,
-			"type": string(state),
-		},
+		Tag:   "presence",
+		Attrs: attrs,
 	})
 }
 
@@ -88,6 +94,9 @@ func (cli *Client) SendPresence(state types.Presence) error {
 //
 //	cli.SendPresence(types.PresenceAvailable)
 func (cli *Client) SubscribePresence(jid types.JID) error {
+	if cli == nil {
+		return ErrClientIsNil
+	}
 	privacyToken, err := cli.Store.PrivacyTokens.GetPrivacyToken(context.TODO(), jid)
 	if err != nil {
 		return fmt.Errorf("failed to get privacy token: %w", err)