slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl

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

@@ -7,16 +7,16 @@
 package whatsmeow
 
 import (
+	"context"
 	"crypto/sha256"
 	"fmt"
 	"time"
 
-	"go.mau.fi/whatsmeow/proto/waCommon"
-	"go.mau.fi/whatsmeow/proto/waE2E"
-
 	"go.mau.fi/util/random"
 	"google.golang.org/protobuf/proto"
 
+	"go.mau.fi/whatsmeow/proto/waCommon"
+	"go.mau.fi/whatsmeow/proto/waE2E"
 	"go.mau.fi/whatsmeow/types"
 	"go.mau.fi/whatsmeow/types/events"
 	"go.mau.fi/whatsmeow/util/gcmutil"
@@ -26,9 +26,13 @@ import (
 type MsgSecretType string
 
 const (
-	EncSecretPollVote MsgSecretType = "Poll Vote"
-	EncSecretReaction MsgSecretType = "Enc Reaction"
-	EncSecretBotMsg   MsgSecretType = "Bot Message"
+	EncSecretPollVote      MsgSecretType = "Poll Vote"
+	EncSecretReaction      MsgSecretType = "Enc Reaction"
+	EncSecretComment       MsgSecretType = "Enc Comment"
+	EncSecretReportToken   MsgSecretType = "Report Token"
+	EncSecretEventResponse MsgSecretType = "Event Response"
+	EncSecretEventEdit     MsgSecretType = "Event Edit"
+	EncSecretBotMsg        MsgSecretType = "Bot Message"
 )
 
 func applyBotMessageHKDF(messageSecret []byte) []byte {
@@ -49,7 +53,11 @@ func generateMsgSecretKey(
 	useCaseSecret = append(useCaseSecret, modificationType...)
 
 	secretKey := hkdfutil.SHA256(origMsgSecret, nil, useCaseSecret, 32)
-	additionalData := []byte(fmt.Sprintf("%s\x00%s", origMsgID, modificationSenderStr))
+	var additionalData []byte
+	switch modificationType {
+	case EncSecretPollVote, EncSecretEventResponse, "":
+		additionalData = fmt.Appendf(nil, "%s\x00%s", origMsgID, modificationSenderStr)
+	}
 
 	return secretKey, additionalData
 }
@@ -57,8 +65,9 @@ func generateMsgSecretKey(
 func getOrigSenderFromKey(msg *events.Message, key *waCommon.MessageKey) (types.JID, error) {
 	if key.GetFromMe() {
 		// fromMe always means the poll and vote were sent by the same user
+		// TODO this is wrong if the message key used @s.whatsapp.net, but the new event is from @lid
 		return msg.Info.Sender, nil
-	} else if msg.Info.Chat.Server == types.DefaultUserServer {
+	} else if msg.Info.Chat.Server == types.DefaultUserServer || msg.Info.Chat.Server == types.HiddenUserServer {
 		sender, err := types.ParseJID(key.GetRemoteJID())
 		if err != nil {
 			return types.EmptyJID, fmt.Errorf("failed to parse JID %q of original message sender: %w", key.GetRemoteJID(), err)
@@ -66,7 +75,7 @@ func getOrigSenderFromKey(msg *events.Message, key *waCommon.MessageKey) (types.
 		return sender, nil
 	} else {
 		sender, err := types.ParseJID(key.GetParticipant())
-		if sender.Server != types.DefaultUserServer {
+		if sender.Server != types.DefaultUserServer && sender.Server != types.HiddenUserServer {
 			err = fmt.Errorf("unexpected server")
 		}
 		if err != nil {
@@ -81,21 +90,34 @@ type messageEncryptedSecret interface {
 	GetEncPayload() []byte
 }
 
-func (cli *Client) decryptMsgSecret(msg *events.Message, useCase MsgSecretType, encrypted messageEncryptedSecret, origMsgKey *waCommon.MessageKey) ([]byte, error) {
+func (cli *Client) decryptMsgSecret(ctx context.Context, msg *events.Message, useCase MsgSecretType, encrypted messageEncryptedSecret, origMsgKey *waCommon.MessageKey) ([]byte, error) {
 	if cli == nil {
 		return nil, ErrClientIsNil
 	}
-	pollSender, err := getOrigSenderFromKey(msg, origMsgKey)
+	origSender, err := getOrigSenderFromKey(msg, origMsgKey)
 	if err != nil {
 		return nil, err
 	}
-	baseEncKey, err := cli.Store.MsgSecrets.GetMessageSecret(msg.Info.Chat, pollSender, origMsgKey.GetID())
+	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: %w", err)
-	} else if baseEncKey == nil {
+	}
+	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
 	}
-	secretKey, additionalData := generateMsgSecretKey(useCase, msg.Info.Sender, origMsgKey.GetID(), pollSender, baseEncKey)
+	secretKey, additionalData := generateMsgSecretKey(useCase, msg.Info.Sender, origMsgKey.GetID(), origSender, baseEncKey)
 	plaintext, err := gcmutil.Decrypt(secretKey, encrypted.GetEncIV(), encrypted.GetEncPayload(), additionalData)
 	if err != nil {
 		return nil, fmt.Errorf("failed to decrypt secret message: %w", err)
@@ -103,16 +125,14 @@ func (cli *Client) decryptMsgSecret(msg *events.Message, useCase MsgSecretType,
 	return plaintext, nil
 }
 
-func (cli *Client) encryptMsgSecret(chat, origSender types.JID, origMsgID types.MessageID, useCase MsgSecretType, plaintext []byte) (ciphertext, iv []byte, err error) {
+func (cli *Client) encryptMsgSecret(ctx context.Context, ownID, chat, origSender types.JID, origMsgID types.MessageID, useCase MsgSecretType, plaintext []byte) (ciphertext, iv []byte, err error) {
 	if cli == nil {
 		return nil, nil, ErrClientIsNil
-	}
-	ownID := cli.getOwnID()
-	if ownID.IsEmpty() {
+	} else if ownID.IsEmpty() {
 		return nil, nil, ErrNotLoggedIn
 	}
 
-	baseEncKey, err := cli.Store.MsgSecrets.GetMessageSecret(chat, origSender, origMsgID)
+	baseEncKey, 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 {
@@ -128,8 +148,7 @@ func (cli *Client) encryptMsgSecret(chat, origSender types.JID, origMsgID types.
 	return ciphertext, iv, nil
 }
 
-func (cli *Client) decryptBotMessage(messageSecret []byte, msMsg messageEncryptedSecret, messageID types.MessageID, targetSenderJID types.JID, info *types.MessageInfo) ([]byte, error) {
-	// gcm decrypt key generation
+func (cli *Client) decryptBotMessage(ctx context.Context, messageSecret []byte, msMsg messageEncryptedSecret, messageID types.MessageID, targetSenderJID types.JID, info *types.MessageInfo) ([]byte, error) {
 	newKey, additionalData := generateMsgSecretKey("", info.Sender, messageID, targetSenderJID, applyBotMessageHKDF(messageSecret))
 
 	plaintext, err := gcmutil.Decrypt(newKey, msMsg.GetEncIV(), msMsg.GetEncPayload(), additionalData)
@@ -140,8 +159,7 @@ func (cli *Client) decryptBotMessage(messageSecret []byte, msMsg messageEncrypte
 	return plaintext, nil
 }
 
-// DecryptReaction decrypts a reaction update message. This form of reactions hasn't been rolled out yet,
-// so this function is likely not of much use.
+// DecryptReaction decrypts a reaction message in a community announcement group.
 //
 //	if evt.Message.GetEncReactionMessage() != nil {
 //		reaction, err := cli.DecryptReaction(evt)
@@ -151,12 +169,12 @@ func (cli *Client) decryptBotMessage(messageSecret []byte, msMsg messageEncrypte
 //		}
 //		fmt.Printf("Reaction message: %+v\n", reaction)
 //	}
-func (cli *Client) DecryptReaction(reaction *events.Message) (*waE2E.ReactionMessage, error) {
+func (cli *Client) DecryptReaction(ctx context.Context, reaction *events.Message) (*waE2E.ReactionMessage, error) {
 	encReaction := reaction.Message.GetEncReactionMessage()
 	if encReaction == nil {
 		return nil, ErrNotEncryptedReactionMessage
 	}
-	plaintext, err := cli.decryptMsgSecret(reaction, EncSecretReaction, encReaction, encReaction.GetTargetMessageKey())
+	plaintext, err := cli.decryptMsgSecret(ctx, reaction, EncSecretReaction, encReaction, encReaction.GetTargetMessageKey())
 	if err != nil {
 		return nil, fmt.Errorf("failed to decrypt reaction: %w", err)
 	}
@@ -168,6 +186,33 @@ func (cli *Client) DecryptReaction(reaction *events.Message) (*waE2E.ReactionMes
 	return &msg, nil
 }
 
+// DecryptComment decrypts a reply/comment message in a community announcement group.
+//
+//	if evt.Message.GetEncCommentMessage() != nil {
+//		comment, err := cli.DecryptComment(evt)
+//		if err != nil {
+//			fmt.Println(":(", err)
+//			return
+//		}
+//		fmt.Printf("Comment message: %+v\n", comment)
+//	}
+func (cli *Client) DecryptComment(ctx context.Context, comment *events.Message) (*waE2E.Message, error) {
+	encComment := comment.Message.GetEncCommentMessage()
+	if encComment == nil {
+		return nil, ErrNotEncryptedCommentMessage
+	}
+	plaintext, err := cli.decryptMsgSecret(ctx, comment, EncSecretComment, encComment, encComment.GetTargetMessageKey())
+	if err != nil {
+		return nil, fmt.Errorf("failed to decrypt comment: %w", err)
+	}
+	var msg waE2E.Message
+	err = proto.Unmarshal(plaintext, &msg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode comment protobuf: %w", err)
+	}
+	return &msg, nil
+}
+
 // DecryptPollVote decrypts a poll update message. The vote itself includes SHA-256 hashes of the selected options.
 //
 //	if evt.Message.GetPollUpdateMessage() != nil {
@@ -181,12 +226,12 @@ func (cli *Client) DecryptReaction(reaction *events.Message) (*waE2E.ReactionMes
 //			fmt.Printf("- %X\n", hash)
 //		}
 //	}
-func (cli *Client) DecryptPollVote(vote *events.Message) (*waE2E.PollVoteMessage, error) {
+func (cli *Client) DecryptPollVote(ctx context.Context, vote *events.Message) (*waE2E.PollVoteMessage, error) {
 	pollUpdate := vote.Message.GetPollUpdateMessage()
 	if pollUpdate == nil {
 		return nil, ErrNotPollUpdateMessage
 	}
-	plaintext, err := cli.decryptMsgSecret(vote, EncSecretPollVote, pollUpdate.GetVote(), pollUpdate.GetPollCreationMessageKey())
+	plaintext, err := cli.decryptMsgSecret(ctx, vote, EncSecretPollVote, pollUpdate.GetVote(), pollUpdate.GetPollCreationMessageKey())
 	if err != nil {
 		return nil, fmt.Errorf("failed to decrypt poll vote: %w", err)
 	}
@@ -234,8 +279,8 @@ func HashPollOptions(optionNames []string) [][]byte {
 //		}
 //		resp, err := cli.SendMessage(context.Background(), evt.Info.Chat, pollVoteMsg)
 //	}
-func (cli *Client) BuildPollVote(pollInfo *types.MessageInfo, optionNames []string) (*waE2E.Message, error) {
-	pollUpdate, err := cli.EncryptPollVote(pollInfo, &waE2E.PollVoteMessage{
+func (cli *Client) BuildPollVote(ctx context.Context, pollInfo *types.MessageInfo, optionNames []string) (*waE2E.Message, error) {
+	pollUpdate, err := cli.EncryptPollVote(ctx, pollInfo, &waE2E.PollVoteMessage{
 		SelectedOptions: HashPollOptions(optionNames),
 	})
 	return &waE2E.Message{PollUpdateMessage: pollUpdate}, err
@@ -267,12 +312,12 @@ func (cli *Client) BuildPollCreation(name string, optionNames []string, selectab
 }
 
 // EncryptPollVote encrypts a poll vote message. This is a slightly lower-level function, using BuildPollVote is recommended.
-func (cli *Client) EncryptPollVote(pollInfo *types.MessageInfo, vote *waE2E.PollVoteMessage) (*waE2E.PollUpdateMessage, error) {
+func (cli *Client) EncryptPollVote(ctx context.Context, pollInfo *types.MessageInfo, vote *waE2E.PollVoteMessage) (*waE2E.PollUpdateMessage, error) {
 	plaintext, err := proto.Marshal(vote)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal poll vote protobuf: %w", err)
 	}
-	ciphertext, iv, err := cli.encryptMsgSecret(pollInfo.Chat, pollInfo.Sender, pollInfo.ID, EncSecretPollVote, plaintext)
+	ciphertext, iv, err := cli.encryptMsgSecret(ctx, cli.getOwnID(), pollInfo.Chat, pollInfo.Sender, pollInfo.ID, EncSecretPollVote, plaintext)
 	if err != nil {
 		return nil, fmt.Errorf("failed to encrypt poll vote: %w", err)
 	}
@@ -285,3 +330,45 @@ func (cli *Client) EncryptPollVote(pollInfo *types.MessageInfo, vote *waE2E.Poll
 		SenderTimestampMS: proto.Int64(time.Now().UnixMilli()),
 	}, nil
 }
+
+func (cli *Client) EncryptComment(ctx context.Context, rootMsgInfo *types.MessageInfo, comment *waE2E.Message) (*waE2E.Message, error) {
+	plaintext, err := proto.Marshal(comment)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal comment protobuf: %w", err)
+	}
+	// TODO is hardcoding LID here correct? What about polls?
+	ciphertext, iv, err := cli.encryptMsgSecret(ctx, cli.getOwnLID(), rootMsgInfo.Chat, rootMsgInfo.Sender, rootMsgInfo.ID, EncSecretComment, plaintext)
+	if err != nil {
+		return nil, fmt.Errorf("failed to encrypt comment: %w", err)
+	}
+	return &waE2E.Message{
+		EncCommentMessage: &waE2E.EncCommentMessage{
+			TargetMessageKey: &waCommon.MessageKey{
+				RemoteJID:   proto.String(rootMsgInfo.Chat.String()),
+				Participant: proto.String(rootMsgInfo.Sender.ToNonAD().String()),
+				FromMe:      proto.Bool(rootMsgInfo.IsFromMe),
+				ID:          proto.String(rootMsgInfo.ID),
+			},
+			EncPayload: ciphertext,
+			EncIV:      iv,
+		},
+	}, nil
+}
+
+func (cli *Client) EncryptReaction(ctx context.Context, rootMsgInfo *types.MessageInfo, reaction *waE2E.ReactionMessage) (*waE2E.EncReactionMessage, error) {
+	reactionKey := reaction.Key
+	reaction.Key = nil
+	plaintext, err := proto.Marshal(reaction)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal reaction protobuf: %w", err)
+	}
+	ciphertext, iv, err := cli.encryptMsgSecret(ctx, cli.getOwnLID(), rootMsgInfo.Chat, rootMsgInfo.Sender, rootMsgInfo.ID, EncSecretReaction, plaintext)
+	if err != nil {
+		return nil, fmt.Errorf("failed to encrypt reaction: %w", err)
+	}
+	return &waE2E.EncReactionMessage{
+		TargetMessageKey: reactionKey,
+		EncPayload:       ciphertext,
+		EncIV:            iv,
+	}, nil
+}

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

@@ -7,8 +7,10 @@
 package whatsmeow
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
+	"slices"
 
 	"google.golang.org/protobuf/proto"
 
@@ -20,7 +22,7 @@ import (
 	"go.mau.fi/whatsmeow/types/events"
 )
 
-func (cli *Client) handleEncryptNotification(node *waBinary.Node) {
+func (cli *Client) handleEncryptNotification(ctx context.Context, node *waBinary.Node) {
 	from := node.AttrGetter().JID("from")
 	if from == types.ServerJID {
 		count := node.GetChildByTag("count")
@@ -32,15 +34,15 @@ func (cli *Client) handleEncryptNotification(node *waBinary.Node) {
 		}
 		cli.Log.Infof("Got prekey count from server: %s", node.XMLString())
 		if otksLeft < MinPreKeyCount {
-			cli.uploadPreKeys()
+			cli.uploadPreKeys(ctx)
 		}
 	} else if _, ok := node.GetOptionalChildByTag("identity"); ok {
 		cli.Log.Debugf("Got identity change for %s: %s, deleting all identities/sessions for that number", from, node.XMLString())
-		err := cli.Store.Identities.DeleteAllIdentities(from.User)
+		err := cli.Store.Identities.DeleteAllIdentities(ctx, from.User)
 		if err != nil {
 			cli.Log.Warnf("Failed to delete all identities of %s from store after identity change: %v", from, err)
 		}
-		err = cli.Store.Sessions.DeleteAllSessions(from.User)
+		err = cli.Store.Sessions.DeleteAllSessions(ctx, from.User)
 		if err != nil {
 			cli.Log.Warnf("Failed to delete all sessions of %s from store after identity change: %v", from, err)
 		}
@@ -51,13 +53,13 @@ func (cli *Client) handleEncryptNotification(node *waBinary.Node) {
 	}
 }
 
-func (cli *Client) handleAppStateNotification(node *waBinary.Node) {
+func (cli *Client) handleAppStateNotification(ctx context.Context, node *waBinary.Node) {
 	for _, collection := range node.GetChildrenByTag("collection") {
 		ag := collection.AttrGetter()
 		name := appstate.WAPatchName(ag.String("name"))
 		version := ag.Uint64("version")
 		cli.Log.Debugf("Got server sync notification that app state %s has updated to version %d", name, version)
-		err := cli.FetchAppState(name, false, false)
+		err := cli.FetchAppState(ctx, name, false, false)
 		if errors.Is(err, ErrIQDisconnected) || errors.Is(err, ErrNotConnected) {
 			// There are some app state changes right before a remote logout, so stop syncing if we're disconnected.
 			cli.Log.Debugf("Failed to sync app state after notification: %v, not trying to sync other states", err)
@@ -68,7 +70,7 @@ func (cli *Client) handleAppStateNotification(node *waBinary.Node) {
 	}
 }
 
-func (cli *Client) handlePictureNotification(node *waBinary.Node) {
+func (cli *Client) handlePictureNotification(ctx context.Context, node *waBinary.Node) {
 	ts := node.AttrGetter().UnixTime("t")
 	for _, child := range node.GetChildren() {
 		ag := child.AttrGetter()
@@ -94,16 +96,26 @@ func (cli *Client) handlePictureNotification(node *waBinary.Node) {
 	}
 }
 
-func (cli *Client) handleDeviceNotification(node *waBinary.Node) {
+func (cli *Client) handleDeviceNotification(ctx context.Context, node *waBinary.Node) {
 	cli.userDevicesCacheLock.Lock()
 	defer cli.userDevicesCacheLock.Unlock()
 	ag := node.AttrGetter()
 	from := ag.JID("from")
+	fromLID := ag.OptionalJID("lid")
+	if fromLID != nil {
+		cli.StoreLIDPNMapping(ctx, *fromLID, from)
+	}
 	cached, ok := cli.userDevicesCache[from]
 	if !ok {
 		cli.Log.Debugf("No device list cached for %s, ignoring device list notification", from)
 		return
 	}
+	var cachedLID deviceCache
+	var cachedLIDHash string
+	if fromLID != nil {
+		cachedLID = cli.userDevicesCache[*fromLID]
+		cachedLIDHash = participantListHashV2(cachedLID.devices)
+	}
 	cachedParticipantHash := participantListHashV2(cached.devices)
 	for _, child := range node.GetChildren() {
 		if child.Tag != "add" && child.Tag != "remove" {
@@ -112,16 +124,24 @@ func (cli *Client) handleDeviceNotification(node *waBinary.Node) {
 		}
 		cag := child.AttrGetter()
 		deviceHash := cag.String("device_hash")
+		deviceLIDHash := cag.OptionalString("device_lid_hash")
 		deviceChild, _ := child.GetOptionalChildByTag("device")
 		changedDeviceJID := deviceChild.AttrGetter().JID("jid")
+		changedDeviceLID := deviceChild.AttrGetter().OptionalJID("lid")
 		switch child.Tag {
 		case "add":
 			cached.devices = append(cached.devices, changedDeviceJID)
+			if changedDeviceLID != nil {
+				cachedLID.devices = append(cachedLID.devices, *changedDeviceLID)
+			}
 		case "remove":
-			for i, jid := range cached.devices {
-				if jid == changedDeviceJID {
-					cached.devices = append(cached.devices[:i], cached.devices[i+1:]...)
-				}
+			cached.devices = slices.DeleteFunc(cached.devices, func(existing types.JID) bool {
+				return existing == changedDeviceJID
+			})
+			if changedDeviceLID != nil {
+				cachedLID.devices = slices.DeleteFunc(cachedLID.devices, func(existing types.JID) bool {
+					return existing == *changedDeviceLID
+				})
 			}
 		case "update":
 			// ???
@@ -134,10 +154,20 @@ func (cli *Client) handleDeviceNotification(node *waBinary.Node) {
 			cli.Log.Warnf("%s's device list hash changed from %s to %s (%s). New hash doesn't match (%s)", from, cachedParticipantHash, deviceHash, child.Tag, newParticipantHash)
 			delete(cli.userDevicesCache, from)
 		}
+		if fromLID != nil && changedDeviceLID != nil && deviceLIDHash != "" {
+			newLIDParticipantHash := participantListHashV2(cachedLID.devices)
+			if newLIDParticipantHash == deviceLIDHash {
+				cli.Log.Debugf("%s's device list hash changed from %s to %s (%s). New hash matches", fromLID, cachedLIDHash, deviceLIDHash, child.Tag)
+				cli.userDevicesCache[*fromLID] = cachedLID
+			} else {
+				cli.Log.Warnf("%s's device list hash changed from %s to %s (%s). New hash doesn't match (%s)", fromLID, cachedLIDHash, deviceLIDHash, child.Tag, newLIDParticipantHash)
+				delete(cli.userDevicesCache, *fromLID)
+			}
+		}
 	}
 }
 
-func (cli *Client) handleFBDeviceNotification(node *waBinary.Node) {
+func (cli *Client) handleFBDeviceNotification(ctx context.Context, node *waBinary.Node) {
 	cli.userDevicesCacheLock.Lock()
 	defer cli.userDevicesCacheLock.Unlock()
 	jid := node.AttrGetter().JID("from")
@@ -145,7 +175,7 @@ func (cli *Client) handleFBDeviceNotification(node *waBinary.Node) {
 	cli.userDevicesCache[jid] = userDevices
 }
 
-func (cli *Client) handleOwnDevicesNotification(node *waBinary.Node) {
+func (cli *Client) handleOwnDevicesNotification(ctx context.Context, node *waBinary.Node) {
 	cli.userDevicesCacheLock.Lock()
 	defer cli.userDevicesCacheLock.Unlock()
 	ownID := cli.getOwnID().ToNonAD()
@@ -177,7 +207,7 @@ func (cli *Client) handleOwnDevicesNotification(node *waBinary.Node) {
 	}
 }
 
-func (cli *Client) handleBlocklist(node *waBinary.Node) {
+func (cli *Client) handleBlocklist(ctx context.Context, node *waBinary.Node) {
 	ag := node.AttrGetter()
 	evt := events.Blocklist{
 		Action:    events.BlocklistAction(ag.OptionalString("action")),
@@ -199,29 +229,30 @@ func (cli *Client) handleBlocklist(node *waBinary.Node) {
 	cli.dispatchEvent(&evt)
 }
 
-func (cli *Client) handleAccountSyncNotification(node *waBinary.Node) {
+func (cli *Client) handleAccountSyncNotification(ctx context.Context, node *waBinary.Node) {
 	for _, child := range node.GetChildren() {
 		switch child.Tag {
 		case "privacy":
-			cli.handlePrivacySettingsNotification(&child)
+			cli.handlePrivacySettingsNotification(ctx, &child)
 		case "devices":
-			cli.handleOwnDevicesNotification(&child)
+			cli.handleOwnDevicesNotification(ctx, &child)
 		case "picture":
 			cli.dispatchEvent(&events.Picture{
 				Timestamp: node.AttrGetter().UnixTime("t"),
 				JID:       cli.getOwnID().ToNonAD(),
 			})
 		case "blocklist":
-			cli.handleBlocklist(&child)
+			cli.handleBlocklist(ctx, &child)
 		default:
 			cli.Log.Debugf("Unhandled account sync item %s", child.Tag)
 		}
 	}
 }
 
-func (cli *Client) handlePrivacyTokenNotification(node *waBinary.Node) {
-	ownID := cli.getOwnID().ToNonAD()
-	if ownID.IsEmpty() {
+func (cli *Client) handlePrivacyTokenNotification(ctx context.Context, node *waBinary.Node) {
+	ownJID := cli.getOwnID().ToNonAD()
+	ownLID := cli.getOwnLID().ToNonAD()
+	if ownJID.IsEmpty() {
 		cli.Log.Debugf("Ignoring privacy token notification, session was deleted")
 		return
 	}
@@ -240,8 +271,11 @@ func (cli *Client) handlePrivacyTokenNotification(node *waBinary.Node) {
 		ag := child.AttrGetter()
 		if child.Tag != "token" {
 			cli.Log.Warnf("privacy_token notification contained unexpected <%s> tag", child.Tag)
-		} else if targetUser := ag.JID("jid"); targetUser != ownID {
-			cli.Log.Warnf("privacy_token notification contained token for different user %s", targetUser)
+		} else if targetUser := ag.JID("jid"); targetUser != ownLID && targetUser != ownJID {
+			// Don't log about own privacy tokens for other users
+			if sender != ownJID && sender != ownLID {
+				cli.Log.Warnf("privacy_token notification contained token for different user %s", targetUser)
+			}
 		} else if tokenType := ag.String("type"); tokenType != "trusted_contact" {
 			cli.Log.Warnf("privacy_token notification contained unexpected token type %s", tokenType)
 		} else if token, ok := child.Content.([]byte); !ok {
@@ -251,7 +285,7 @@ func (cli *Client) handlePrivacyTokenNotification(node *waBinary.Node) {
 			if !ag.OK() {
 				cli.Log.Warnf("privacy_token notification is missing some fields: %v", ag.Error())
 			}
-			err := cli.Store.PrivacyTokens.PutPrivacyTokens(store.PrivacyToken{
+			err := cli.Store.PrivacyTokens.PutPrivacyTokens(ctx, store.PrivacyToken{
 				User:      sender,
 				Token:     token,
 				Timestamp: timestamp,
@@ -308,7 +342,7 @@ func (cli *Client) parseNewsletterMessages(node *waBinary.Node) []*types.Newslet
 	return output
 }
 
-func (cli *Client) handleNewsletterNotification(node *waBinary.Node) {
+func (cli *Client) handleNewsletterNotification(ctx context.Context, node *waBinary.Node) {
 	ag := node.AttrGetter()
 	liveUpdates := node.GetChildByTag("live_updates")
 	cli.dispatchEvent(&events.NewsletterLiveUpdate{
@@ -331,7 +365,7 @@ type newsletterEvent struct {
 	// _on_state_change -> id, is_requestor, state
 }
 
-func (cli *Client) handleMexNotification(node *waBinary.Node) {
+func (cli *Client) handleMexNotification(ctx context.Context, node *waBinary.Node) {
 	for _, child := range node.GetChildren() {
 		if child.Tag != "update" {
 			continue
@@ -356,7 +390,7 @@ func (cli *Client) handleMexNotification(node *waBinary.Node) {
 	}
 }
 
-func (cli *Client) handleStatusNotification(node *waBinary.Node) {
+func (cli *Client) handleStatusNotification(ctx context.Context, node *waBinary.Node) {
 	ag := node.AttrGetter()
 	child, found := node.GetOptionalChildByTag("set")
 	if !found {
@@ -376,44 +410,46 @@ func (cli *Client) handleStatusNotification(node *waBinary.Node) {
 }
 
 func (cli *Client) handleNotification(node *waBinary.Node) {
+	ctx := cli.BackgroundEventCtx
 	ag := node.AttrGetter()
 	notifType := ag.String("type")
 	if !ag.OK() {
 		return
 	}
-	defer cli.maybeDeferredAck(node)()
+	var cancelled bool
+	defer cli.maybeDeferredAck(ctx, node)(&cancelled)
 	switch notifType {
 	case "encrypt":
-		go cli.handleEncryptNotification(node)
+		go cli.handleEncryptNotification(ctx, node)
 	case "server_sync":
-		go cli.handleAppStateNotification(node)
+		go cli.handleAppStateNotification(ctx, node)
 	case "account_sync":
-		go cli.handleAccountSyncNotification(node)
+		go cli.handleAccountSyncNotification(ctx, node)
 	case "devices":
-		cli.handleDeviceNotification(node)
+		cli.handleDeviceNotification(ctx, node)
 	case "fbid:devices":
-		cli.handleFBDeviceNotification(node)
+		cli.handleFBDeviceNotification(ctx, node)
 	case "w:gp2":
 		evt, err := cli.parseGroupNotification(node)
 		if err != nil {
 			cli.Log.Errorf("Failed to parse group notification: %v", err)
 		} else {
-			cli.dispatchEvent(evt)
+			cancelled = cli.dispatchEvent(evt)
 		}
 	case "picture":
-		cli.handlePictureNotification(node)
+		cli.handlePictureNotification(ctx, node)
 	case "mediaretry":
-		cli.handleMediaRetryNotification(node)
+		cli.handleMediaRetryNotification(ctx, node)
 	case "privacy_token":
-		cli.handlePrivacyTokenNotification(node)
+		cli.handlePrivacyTokenNotification(ctx, node)
 	case "link_code_companion_reg":
-		go cli.tryHandleCodePairNotification(node)
+		go cli.tryHandleCodePairNotification(ctx, node)
 	case "newsletter":
-		cli.handleNewsletterNotification(node)
+		cli.handleNewsletterNotification(ctx, node)
 	case "mex":
-		cli.handleMexNotification(node)
+		cli.handleMexNotification(ctx, node)
 	case "status":
-		cli.handleStatusNotification(node)
+		cli.handleStatusNotification(ctx, node)
 	// Other types: business, disappearing_mode, server, status, pay, psa
 	default:
 		cli.Log.Debugf("Unhandled notification with type %s", notifType)

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

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/sha256"
@@ -86,7 +87,7 @@ func generateCompanionEphemeralKey() (ephemeralKeyPair *keys.KeyPair, ephemeralK
 // (the server will validate it and return 400 if it's wrong).
 //
 // See https://faq.whatsapp.com/1324084875126592 for more info
-func (cli *Client) PairPhone(phone string, showPushNotification bool, clientType PairClientType, clientDisplayName string) (string, error) {
+func (cli *Client) PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType PairClientType, clientDisplayName string) (string, error) {
 	if cli == nil {
 		return "", ErrClientIsNil
 	}
@@ -102,6 +103,7 @@ func (cli *Client) PairPhone(phone string, showPushNotification bool, clientType
 		Namespace: "md",
 		Type:      iqSet,
 		To:        types.ServerJID,
+		Context:   ctx,
 		Content: []waBinary.Node{{
 			Tag: "link_code_companion_reg",
 			Attrs: waBinary.Attrs{
@@ -139,14 +141,14 @@ func (cli *Client) PairPhone(phone string, showPushNotification bool, clientType
 	return encodedLinkingCode[0:4] + "-" + encodedLinkingCode[4:], nil
 }
 
-func (cli *Client) tryHandleCodePairNotification(parentNode *waBinary.Node) {
-	err := cli.handleCodePairNotification(parentNode)
+func (cli *Client) tryHandleCodePairNotification(ctx context.Context, parentNode *waBinary.Node) {
+	err := cli.handleCodePairNotification(ctx, parentNode)
 	if err != nil {
 		cli.Log.Errorf("Failed to handle code pair notification: %s", err)
 	}
 }
 
-func (cli *Client) handleCodePairNotification(parentNode *waBinary.Node) error {
+func (cli *Client) handleCodePairNotification(ctx context.Context, parentNode *waBinary.Node) error {
 	node, ok := parentNode.GetOptionalChildByTag("link_code_companion_reg")
 	if !ok {
 		return &ElementMissingError{
@@ -225,6 +227,7 @@ func (cli *Client) handleCodePairNotification(parentNode *waBinary.Node) error {
 		Namespace: "md",
 		Type:      iqSet,
 		To:        types.ServerJID,
+		Context:   ctx,
 		Content: []waBinary.Node{{
 			Tag: "link_code_companion_reg",
 			Attrs: waBinary.Attrs{