slidge-whatsapp 0.3.0b0__cp311-cp311-manylinux_2_36_aarch64.whl → 0.3.1__cp311-cp311-manylinux_2_36_aarch64.whl

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

@@ -13,6 +13,8 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/rs/zerolog"
+
 	"go.mau.fi/whatsmeow/appstate"
 	waBinary "go.mau.fi/whatsmeow/binary"
 	"go.mau.fi/whatsmeow/proto/waE2E"
@@ -110,6 +112,7 @@ func (cli *Client) filterContacts(mutations []appstate.Mutation) ([]appstate.Mut
 }
 
 func (cli *Client) dispatchAppState(ctx context.Context, mutation appstate.Mutation, fullSync bool, emitOnFullSync bool) {
+	zerolog.Ctx(ctx).Trace().Any("mutation", mutation).Msg("Dispatching app state mutation")
 	dispatchEvts := !fullSync || emitOnFullSync
 
 	if mutation.Operation != waServerSync.SyncdMutation_SET {

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

@@ -22,7 +22,7 @@ import (
 	"go.mau.fi/whatsmeow/types/events"
 )
 
-func (cli *Client) handleDecryptedArmadillo(ctx context.Context, info *types.MessageInfo, decrypted []byte, retryCount int) (handled, handlerFailed bool) {
+func (cli *Client) handleDecryptedArmadillo(ctx context.Context, info *types.MessageInfo, decrypted []byte, retryCount int) (handlerFailed bool) {
 	dec, err := decodeArmadillo(decrypted)
 	if err != nil {
 		cli.Log.Warnf("Failed to decode armadillo message from %s: %v", info.SourceString(), err)
@@ -41,7 +41,6 @@ func (cli *Client) handleDecryptedArmadillo(ctx context.Context, info *types.Mes
 	if dec.Message != nil || dec.FBApplication != nil {
 		handlerFailed = cli.dispatchEvent(&dec)
 	}
-	handled = true
 	return
 }
 

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

@@ -29,6 +29,12 @@ func (cli *Client) handleCallEvent(node *waBinary.Node) {
 		CallID:      cag.String("call-id"),
 		GroupJID:    cag.OptionalJIDOrEmpty("group-jid"),
 	}
+	if basicMeta.CallCreator.Server == types.HiddenUserServer {
+		basicMeta.CallCreatorAlt = cag.OptionalJIDOrEmpty("caller_pn")
+	} else {
+		// This may not actually exist
+		basicMeta.CallCreatorAlt = cag.OptionalJIDOrEmpty("caller_lid")
+	}
 	switch child.Tag {
 	case "offer":
 		cli.dispatchEvent(&events.CallOffer{

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

@@ -145,6 +145,7 @@ var (
 	ErrOriginalMessageSecretNotFound = errors.New("original message secret key not found")
 	ErrNotEncryptedReactionMessage   = errors.New("given message isn't an encrypted reaction message")
 	ErrNotEncryptedCommentMessage    = errors.New("given message isn't an encrypted comment message")
+	ErrNotSecretEncryptedMessage     = errors.New("given message isn't a secret encrypted message")
 	ErrNotPollUpdateMessage          = errors.New("given message isn't a poll update message")
 )
 

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

@@ -493,8 +493,8 @@ func (cli *Client) JoinGroupWithLink(code string) (types.JID, error) {
 }
 
 // GetJoinedGroups returns the list of groups the user is participating in.
-func (cli *Client) GetJoinedGroups() ([]*types.GroupInfo, error) {
-	resp, err := cli.sendGroupIQ(context.TODO(), iqGet, types.GroupServerJID, waBinary.Node{
+func (cli *Client) GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error) {
+	resp, err := cli.sendGroupIQ(ctx, iqGet, types.GroupServerJID, waBinary.Node{
 		Tag: "participating",
 		Content: []waBinary.Node{
 			{Tag: "participants"},
@@ -510,6 +510,8 @@ func (cli *Client) GetJoinedGroups() ([]*types.GroupInfo, error) {
 	}
 	children := groups.GetChildren()
 	infos := make([]*types.GroupInfo, 0, len(children))
+	var allLIDPairs []store.LIDMapping
+	var allRedactedPhones []store.RedactedPhoneEntry
 	for _, child := range children {
 		if child.Tag != "group" {
 			cli.Log.Debugf("Unexpected child in group list response: %s", child.XMLString())
@@ -519,8 +521,19 @@ func (cli *Client) GetJoinedGroups() ([]*types.GroupInfo, error) {
 		if parseErr != nil {
 			cli.Log.Warnf("Error parsing group %s: %v", parsed.JID, parseErr)
 		}
+		lidPairs, redactedPhones := cli.cacheGroupInfo(parsed, true)
+		allLIDPairs = append(allLIDPairs, lidPairs...)
+		allRedactedPhones = append(allRedactedPhones, redactedPhones...)
 		infos = append(infos, parsed)
 	}
+	err = cli.Store.LIDs.PutManyLIDMappings(ctx, allLIDPairs)
+	if err != nil {
+		cli.Log.Warnf("Failed to store LID mappings from joined groups: %v", err)
+	}
+	err = cli.Store.Contacts.PutManyRedactedPhones(ctx, allRedactedPhones)
+	if err != nil {
+		cli.Log.Warnf("Failed to store redacted phones from joined groups: %v", err)
+	}
 	return infos, nil
 }
 
@@ -572,6 +585,37 @@ func (cli *Client) GetGroupInfo(jid types.JID) (*types.GroupInfo, error) {
 	return cli.getGroupInfo(context.TODO(), jid, true)
 }
 
+func (cli *Client) cacheGroupInfo(groupInfo *types.GroupInfo, lock bool) ([]store.LIDMapping, []store.RedactedPhoneEntry) {
+	participants := make([]types.JID, len(groupInfo.Participants))
+	lidPairs := make([]store.LIDMapping, len(groupInfo.Participants))
+	redactedPhones := make([]store.RedactedPhoneEntry, 0)
+	for i, part := range groupInfo.Participants {
+		participants[i] = part.JID
+		if !part.PhoneNumber.IsEmpty() && !part.LID.IsEmpty() {
+			lidPairs[i] = store.LIDMapping{
+				LID: part.LID,
+				PN:  part.PhoneNumber,
+			}
+		}
+		if part.DisplayName != "" && !part.LID.IsEmpty() {
+			redactedPhones = append(redactedPhones, store.RedactedPhoneEntry{
+				JID:           part.LID,
+				RedactedPhone: part.DisplayName,
+			})
+		}
+	}
+	if lock {
+		cli.groupCacheLock.Lock()
+		defer cli.groupCacheLock.Unlock()
+	}
+	cli.groupCache[groupInfo.JID] = &groupMetaCache{
+		AddressingMode:             groupInfo.AddressingMode,
+		CommunityAnnouncementGroup: groupInfo.IsAnnounce && groupInfo.IsDefaultSubGroup,
+		Members:                    participants,
+	}
+	return lidPairs, redactedPhones
+}
+
 func (cli *Client) getGroupInfo(ctx context.Context, jid types.JID, lockParticipantCache bool) (*types.GroupInfo, error) {
 	res, err := cli.sendGroupIQ(ctx, iqGet, jid, waBinary.Node{
 		Tag:   "query",
@@ -593,30 +637,15 @@ func (cli *Client) getGroupInfo(ctx context.Context, jid types.JID, lockParticip
 	if err != nil {
 		return groupInfo, err
 	}
-	if lockParticipantCache {
-		cli.groupCacheLock.Lock()
-		defer cli.groupCacheLock.Unlock()
-	}
-	participants := make([]types.JID, len(groupInfo.Participants))
-	lidPairs := make([]store.LIDMapping, len(groupInfo.Participants))
-	for i, part := range groupInfo.Participants {
-		participants[i] = part.JID
-		if !part.PhoneNumber.IsEmpty() && !part.LID.IsEmpty() {
-			lidPairs[i] = store.LIDMapping{
-				LID: part.LID,
-				PN:  part.PhoneNumber,
-			}
-		}
-	}
-	cli.groupCache[jid] = &groupMetaCache{
-		AddressingMode:             groupInfo.AddressingMode,
-		CommunityAnnouncementGroup: groupInfo.IsAnnounce && groupInfo.IsDefaultSubGroup,
-		Members:                    participants,
-	}
+	lidPairs, redactedPhones := cli.cacheGroupInfo(groupInfo, lockParticipantCache)
 	err = cli.Store.LIDs.PutManyLIDMappings(ctx, lidPairs)
 	if err != nil {
 		cli.Log.Warnf("Failed to store LID mappings for members of %s: %v", jid, err)
 	}
+	err = cli.Store.Contacts.PutManyRedactedPhones(ctx, redactedPhones)
+	if err != nil {
+		cli.Log.Warnf("Failed to store redacted phones for members of %s: %v", jid, err)
+	}
 	return groupInfo, nil
 }
 
@@ -670,8 +699,8 @@ func (cli *Client) parseGroupNode(groupNode *waBinary.Node) (*types.GroupInfo, e
 	group.OwnerJID = ag.OptionalJIDOrEmpty("creator")
 	group.OwnerPN = ag.OptionalJIDOrEmpty("creator_pn")
 
-	group.Name = ag.String("subject")
-	group.NameSetAt = ag.UnixTime("s_t")
+	group.Name = ag.OptionalString("subject")
+	group.NameSetAt = ag.OptionalUnixTime("s_t")
 	group.NameSetBy = ag.OptionalJIDOrEmpty("s_o")
 	group.NameSetByPN = ag.OptionalJIDOrEmpty("s_o_pn")
 
@@ -738,8 +767,8 @@ func parseGroupLinkTargetNode(groupNode *waBinary.Node) (types.GroupLinkTarget,
 	return types.GroupLinkTarget{
 		JID: jidKey,
 		GroupName: types.GroupName{
-			Name:      ag.String("subject"),
-			NameSetAt: ag.UnixTime("s_t"),
+			Name:      ag.OptionalString("subject"),
+			NameSetAt: ag.OptionalUnixTime("s_t"),
 		},
 		GroupIsDefaultSub: types.GroupIsDefaultSub{
 			IsDefaultSubGroup: groupNode.GetChildByTag("default_sub_group").Tag == "default_sub_group",
@@ -777,10 +806,10 @@ func parseParticipantList(node *waBinary.Node) (participants []types.JID, lidPai
 	return
 }
 
-func (cli *Client) parseGroupCreate(parentNode, node *waBinary.Node) (*events.JoinedGroup, []store.LIDMapping, error) {
+func (cli *Client) parseGroupCreate(parentNode, node *waBinary.Node) (*events.JoinedGroup, []store.LIDMapping, []store.RedactedPhoneEntry, error) {
 	groupNode, ok := node.GetOptionalChildByTag("group")
 	if !ok {
-		return nil, nil, fmt.Errorf("group create notification didn't contain group info")
+		return nil, nil, nil, fmt.Errorf("group create notification didn't contain group info")
 	}
 	var evt events.JoinedGroup
 	pag := parentNode.AttrGetter()
@@ -793,19 +822,11 @@ 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, nil, fmt.Errorf("failed to parse group info in create notification: %w", err)
+		return nil, nil, nil, fmt.Errorf("failed to parse group info in create notification: %w", err)
 	}
 	evt.GroupInfo = *info
-	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
+	lidPairs, redactedPhones := cli.cacheGroupInfo(info, true)
+	return &evt, lidPairs, redactedPhones, nil
 }
 
 func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, []store.LIDMapping, error) {
@@ -965,17 +986,17 @@ Outer:
 	}
 }
 
-func (cli *Client) parseGroupNotification(node *waBinary.Node) (any, []store.LIDMapping, error) {
+func (cli *Client) parseGroupNotification(node *waBinary.Node) (any, []store.LIDMapping, []store.RedactedPhoneEntry, error) {
 	children := node.GetChildren()
 	if len(children) == 1 && children[0].Tag == "create" {
 		return cli.parseGroupCreate(node, &children[0])
 	} else {
 		groupChange, lidPairs, err := cli.parseGroupChange(node)
 		if err != nil {
-			return nil, nil, err
+			return nil, nil, nil, err
 		}
 		cli.updateGroupParticipantCache(groupChange)
-		return groupChange, lidPairs, nil
+		return groupChange, lidPairs, nil, nil
 	}
 }
 

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

@@ -67,7 +67,7 @@ func (int *DangerousInternalClient) RequestAppStateKeys(ctx context.Context, raw
 	int.c.requestAppStateKeys(ctx, rawKeyIDs)
 }
 
-func (int *DangerousInternalClient) HandleDecryptedArmadillo(ctx context.Context, info *types.MessageInfo, decrypted []byte, retryCount int) (handled, handlerFailed bool) {
+func (int *DangerousInternalClient) HandleDecryptedArmadillo(ctx context.Context, info *types.MessageInfo, decrypted []byte, retryCount int) (handlerFailed bool) {
 	return int.c.handleDecryptedArmadillo(ctx, info, decrypted, retryCount)
 }
 
@@ -207,6 +207,10 @@ func (int *DangerousInternalClient) SendGroupIQ(ctx context.Context, iqType info
 	return int.c.sendGroupIQ(ctx, iqType, jid, content)
 }
 
+func (int *DangerousInternalClient) CacheGroupInfo(groupInfo *types.GroupInfo, lock bool) ([]store.LIDMapping, []store.RedactedPhoneEntry) {
+	return int.c.cacheGroupInfo(groupInfo, lock)
+}
+
 func (int *DangerousInternalClient) GetGroupInfo(ctx context.Context, jid types.JID, lockParticipantCache bool) (*types.GroupInfo, error) {
 	return int.c.getGroupInfo(ctx, jid, lockParticipantCache)
 }
@@ -219,7 +223,7 @@ func (int *DangerousInternalClient) ParseGroupNode(groupNode *waBinary.Node) (*t
 	return int.c.parseGroupNode(groupNode)
 }
 
-func (int *DangerousInternalClient) ParseGroupCreate(parentNode, node *waBinary.Node) (*events.JoinedGroup, []store.LIDMapping, error) {
+func (int *DangerousInternalClient) ParseGroupCreate(parentNode, node *waBinary.Node) (*events.JoinedGroup, []store.LIDMapping, []store.RedactedPhoneEntry, error) {
 	return int.c.parseGroupCreate(parentNode, node)
 }
 
@@ -231,7 +235,7 @@ func (int *DangerousInternalClient) UpdateGroupParticipantCache(evt *events.Grou
 	int.c.updateGroupParticipantCache(evt)
 }
 
-func (int *DangerousInternalClient) ParseGroupNotification(node *waBinary.Node) (any, []store.LIDMapping, error) {
+func (int *DangerousInternalClient) ParseGroupNotification(node *waBinary.Node) (any, []store.LIDMapping, []store.RedactedPhoneEntry, error) {
 	return int.c.parseGroupNotification(node)
 }
 
@@ -287,8 +291,8 @@ func (int *DangerousInternalClient) MigrateSessionStore(ctx context.Context, pn,
 	int.c.migrateSessionStore(ctx, pn, lid)
 }
 
-func (int *DangerousInternalClient) DecryptMessages(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) (handlerFailed bool) {
-	return int.c.decryptMessages(ctx, info, node)
+func (int *DangerousInternalClient) DecryptMessages(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) {
+	int.c.decryptMessages(ctx, info, node)
 }
 
 func (int *DangerousInternalClient) ClearUntrustedIdentity(ctx context.Context, target types.JID) error {
@@ -651,16 +655,16 @@ func (int *DangerousInternalClient) MakeDeviceIdentityNode() waBinary.Node {
 	return int.c.makeDeviceIdentityNode()
 }
 
-func (int *DangerousInternalClient) EncryptMessageForDevices(ctx context.Context, allDevices []types.JID, id string, msgPlaintext, dsmPlaintext []byte, encAttrs waBinary.Attrs) ([]waBinary.Node, bool) {
+func (int *DangerousInternalClient) EncryptMessageForDevices(ctx context.Context, allDevices []types.JID, id string, msgPlaintext, dsmPlaintext []byte, encAttrs waBinary.Attrs) ([]waBinary.Node, bool, error) {
 	return int.c.encryptMessageForDevices(ctx, allDevices, id, msgPlaintext, dsmPlaintext, encAttrs)
 }
 
-func (int *DangerousInternalClient) EncryptMessageForDeviceAndWrap(ctx context.Context, plaintext []byte, wireIdentity, encryptionIdentity types.JID, bundle *prekey.Bundle, encAttrs waBinary.Attrs) (*waBinary.Node, bool, error) {
-	return int.c.encryptMessageForDeviceAndWrap(ctx, plaintext, wireIdentity, encryptionIdentity, bundle, encAttrs)
+func (int *DangerousInternalClient) EncryptMessageForDeviceAndWrap(ctx context.Context, plaintext []byte, wireIdentity, encryptionIdentity types.JID, bundle *prekey.Bundle, encAttrs waBinary.Attrs, existingSessions map[string]bool) (*waBinary.Node, bool, error) {
+	return int.c.encryptMessageForDeviceAndWrap(ctx, plaintext, wireIdentity, encryptionIdentity, bundle, encAttrs, existingSessions)
 }
 
-func (int *DangerousInternalClient) EncryptMessageForDevice(ctx context.Context, plaintext []byte, to types.JID, bundle *prekey.Bundle, extraAttrs waBinary.Attrs) (*waBinary.Node, bool, error) {
-	return int.c.encryptMessageForDevice(ctx, plaintext, to, bundle, extraAttrs)
+func (int *DangerousInternalClient) EncryptMessageForDevice(ctx context.Context, plaintext []byte, to types.JID, bundle *prekey.Bundle, extraAttrs waBinary.Attrs, existingSessions map[string]bool) (*waBinary.Node, bool, error) {
+	return int.c.encryptMessageForDevice(ctx, plaintext, to, bundle, extraAttrs, existingSessions)
 }
 
 func (int *DangerousInternalClient) RawUpload(ctx context.Context, dataToUpload io.Reader, uploadSize uint64, fileHash []byte, appInfo MediaType, newsletter bool, resp *UploadResponse) error {

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

@@ -57,12 +57,12 @@ func (cli *Client) handleEncryptedMessage(node *waBinary.Node) {
 		if len(info.PushName) > 0 && info.PushName != "-" && (cli.MessengerConfig == nil || info.PushName != "username") {
 			go cli.updatePushName(cli.BackgroundEventCtx, info.Sender, info, info.PushName)
 		}
-		var cancelled bool
-		defer cli.maybeDeferredAck(ctx, node)(&cancelled)
 		if info.Sender.Server == types.NewsletterServer {
+			var cancelled bool
+			defer cli.maybeDeferredAck(ctx, node)(&cancelled)
 			cancelled = cli.handlePlaintextMessage(ctx, info, node)
 		} else {
-			cancelled = cli.decryptMessages(ctx, info, node)
+			cli.decryptMessages(ctx, info, node)
 		}
 	}
 }
@@ -95,6 +95,29 @@ func (cli *Client) parseMessageSource(node *waBinary.Node, requireParticipant bo
 		}
 		if from.Server == types.BroadcastServer {
 			source.BroadcastListOwner = ag.OptionalJIDOrEmpty("recipient")
+			participants, ok := node.GetOptionalChildByTag("participants")
+			if ok && source.IsFromMe {
+				children := participants.GetChildren()
+				source.BroadcastRecipients = make([]types.BroadcastRecipient, 0, len(children))
+				for _, child := range children {
+					if child.Tag != "to" {
+						continue
+					}
+					cag := child.AttrGetter()
+					mainJID := cag.JID("jid")
+					if mainJID.Server == types.HiddenUserServer {
+						source.BroadcastRecipients = append(source.BroadcastRecipients, types.BroadcastRecipient{
+							LID: mainJID,
+							PN:  cag.OptionalJIDOrEmpty("peer_recipient_pn"),
+						})
+					} else {
+						source.BroadcastRecipients = append(source.BroadcastRecipients, types.BroadcastRecipient{
+							LID: cag.OptionalJIDOrEmpty("peer_recipient_lid"),
+							PN:  mainJID,
+						})
+					}
+				}
+			}
 		}
 	} else if from.Server == types.NewsletterServer {
 		source.Chat = from
@@ -263,15 +286,17 @@ func (cli *Client) migrateSessionStore(ctx context.Context, pn, lid types.JID) {
 	}
 }
 
-func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) (handlerFailed bool) {
+func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) {
 	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)
 		if cli.SynchronousAck {
 			cli.immediateRequestMessageFromPhone(ctx, info)
+			cli.sendAck(node)
 		} else {
 			go cli.delayedRequestMessageFromPhone(info)
+			go cli.sendAck(node)
 		}
 		cli.dispatchEvent(&events.UndecryptableMessage{Info: *info, IsUnavailable: true, UnavailableType: uType})
 		return
@@ -279,7 +304,6 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 
 	children := node.GetChildren()
 	cli.Log.Debugf("Decrypting message from %s", info.SourceString())
-	handled := false
 	containsDirectMsg := false
 	senderEncryptionJID := info.Sender
 	if info.Sender.Server == types.DefaultUserServer && !info.Sender.IsBot() {
@@ -346,22 +370,19 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 
 		if errors.Is(err, EventAlreadyProcessed) {
 			cli.Log.Debugf("Ignoring message %s from %s: %v", info.ID, info.SourceString(), err)
-			return
+			continue
 		} else if err != nil {
 			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" {
-				if cli.SynchronousAck {
-					cli.sendRetryReceipt(ctx, node, info, isUnavailable)
-				} else {
-					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)
 			}
-			handlerFailed = cli.dispatchEvent(&events.UndecryptableMessage{
+			cli.dispatchEvent(&events.UndecryptableMessage{
 				Info:            *info,
 				IsUnavailable:   isUnavailable,
 				DecryptFailMode: events.DecryptFailMode(ag.OptionalString("decrypt-fail")),
@@ -372,33 +393,37 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 		cli.cancelDelayedRequestFromPhone(info.ID)
 
 		var msg waE2E.Message
+		var handlerFailed bool
 		switch ag.Int("v") {
 		case 2:
+			// TODO send nack instead of receipt for proto unmarshal errors (both this one and armadillo)
 			err = proto.Unmarshal(decrypted, &msg)
 			if err != nil {
 				cli.Log.Warnf("Error unmarshaling decrypted message from %s: %v", info.SourceString(), err)
 				continue
 			}
 			handlerFailed = cli.handleDecryptedMessage(ctx, info, &msg, retryCount)
-			handled = true
 		case 3:
-			handled, handlerFailed = cli.handleDecryptedArmadillo(ctx, info, decrypted, retryCount)
+			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 handlerFailed {
 			cli.Log.Warnf("Handler for %s failed", info.ID)
+			return
 		}
-		if ciphertextHash != nil && cli.EnableDecryptedEventBuffer && !handlerFailed {
+		if ciphertextHash != nil && cli.EnableDecryptedEventBuffer {
 			// Use the context passed to decryptMessages
 			err = cli.Store.EventBuffer.ClearBufferedEventPlaintext(ctx, *ciphertextHash)
 			if err != nil {
 				zerolog.Ctx(ctx).Err(err).
 					Hex("ciphertext_hash", ciphertextHash[:]).
+					Str("message_id", info.ID).
 					Msg("Failed to clear buffered event plaintext")
 			} else {
 				zerolog.Ctx(ctx).Debug().
 					Hex("ciphertext_hash", ciphertextHash[:]).
+					Str("message_id", info.ID).
 					Msg("Deleted event plaintext from buffer")
 			}
 
@@ -413,7 +438,9 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo,
 			}
 		}
 	}
-	if handled && !handlerFailed {
+	if cli.SynchronousAck {
+		cli.sendMessageReceipt(info)
+	} else {
 		go cli.sendMessageReceipt(info)
 	}
 	return

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

@@ -231,6 +231,29 @@ func (cli *Client) DecryptPollVote(ctx context.Context, vote *events.Message) (*
 	return &msg, nil
 }
 
+func (cli *Client) DecryptSecretEncryptedMessage(ctx context.Context, evt *events.Message) (*waE2E.Message, error) {
+	encMessage := evt.Message.GetSecretEncryptedMessage()
+	if encMessage == nil {
+		return nil, ErrNotSecretEncryptedMessage
+	}
+	if encMessage.GetSecretEncType() != waE2E.SecretEncryptedMessage_EVENT_EDIT {
+		return nil, fmt.Errorf("unsupported secret enc type: %s", encMessage.SecretEncType.String())
+	}
+	plaintext, err := cli.decryptMsgSecret(ctx, evt, EncSecretEventEdit, encMessage, encMessage.GetTargetMessageKey())
+	if err != nil {
+		return nil, fmt.Errorf("failed to decrypt message: %w", err)
+	}
+	var msg waE2E.Message
+	err = proto.Unmarshal(plaintext, &msg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode message protobuf: %w", err)
+	}
+	if evt.Message.MessageContextInfo != nil && msg.MessageContextInfo == nil {
+		msg.MessageContextInfo = evt.Message.MessageContextInfo
+	}
+	return &msg, nil
+}
+
 func getKeyFromInfo(msgInfo *types.MessageInfo) *waCommon.MessageKey {
 	creationKey := &waCommon.MessageKey{
 		RemoteJID: proto.String(msgInfo.Chat.String()),

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

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

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

@@ -134,7 +134,7 @@ func (cli *Client) handlePair(ctx context.Context, deviceIdentityBytes []byte, r
 		return &PairProtoError{"failed to parse signed device identity in pair success message", err}
 	}
 
-	if !verifyDeviceIdentityAccountSignature(&deviceIdentity, cli.Store.IdentityKey, isHostedAccount) {
+	if !verifyDeviceIdentityAccountSignature(&deviceIdentity, cli.Store.IdentityKey) {
 		cli.sendPairError(reqID, 401, "signature-mismatch")
 		return ErrPairInvalidDeviceSignature
 	}
@@ -224,7 +224,7 @@ func concatBytes(data ...[]byte) []byte {
 	return output
 }
 
-func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair, isHostedAccount bool) bool {
+func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair) bool {
 	if len(deviceIdentity.AccountSignatureKey) != 32 || len(deviceIdentity.AccountSignature) != 64 {
 		return false
 	}
@@ -232,11 +232,7 @@ func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceI
 	signatureKey := ecc.NewDjbECPublicKey(*(*[32]byte)(deviceIdentity.AccountSignatureKey))
 	signature := *(*[64]byte)(deviceIdentity.AccountSignature)
 
-	prefix := AdvPrefixAccountSignature
-	if isHostedAccount {
-		prefix = AdvHostedPrefixDeviceIdentityAccountSignature
-	}
-	message := concatBytes(prefix, deviceIdentity.Details, ikp.Pub[:])
+	message := concatBytes(AdvPrefixAccountSignature, deviceIdentity.Details, ikp.Pub[:])
 	return ecc.VerifySignature(signatureKey, message, signature)
 }