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

slidge_whatsapp/vendor/go.mau.fi/util/jsontime/helpers.go

@@ -10,12 +10,19 @@ import (
 	"time"
 )
 
+func zeroSafeUnixToTime(val int64, fn func(int64) time.Time) time.Time {
+	if val == 0 {
+		return time.Time{}
+	}
+	return fn(val)
+}
+
 func UM(time time.Time) UnixMilli {
 	return UnixMilli{Time: time}
 }
 
 func UMInt(ts int64) UnixMilli {
-	return UM(time.UnixMilli(ts))
+	return UM(zeroSafeUnixToTime(ts, time.UnixMilli))
 }
 
 func UnixMilliNow() UnixMilli {
@@ -26,8 +33,8 @@ func UMicro(time time.Time) UnixMicro {
 	return UnixMicro{Time: time}
 }
 
-func UMicroInto(ts int64) UnixMicro {
-	return UMicro(time.UnixMicro(ts))
+func UMicroInt(ts int64) UnixMicro {
+	return UMicro(zeroSafeUnixToTime(ts, time.UnixMicro))
 }
 
 func UnixMicroNow() UnixMicro {
@@ -39,7 +46,9 @@ func UN(time time.Time) UnixNano {
 }
 
 func UNInt(ts int64) UnixNano {
-	return UN(time.Unix(0, ts))
+	return UN(zeroSafeUnixToTime(ts, func(i int64) time.Time {
+		return time.Unix(0, i)
+	}))
 }
 
 func UnixNanoNow() UnixNano {
@@ -51,7 +60,9 @@ func U(time time.Time) Unix {
 }
 
 func UInt(ts int64) Unix {
-	return U(time.Unix(ts, 0))
+	return U(zeroSafeUnixToTime(ts, func(i int64) time.Time {
+		return time.Unix(i, 0)
+	}))
 }
 
 func UnixNow() Unix {

slidge_whatsapp/vendor/go.mau.fi/util/jsontime/integer.go

@@ -57,6 +57,13 @@ func anyIntegerToTime(src any, unixConv func(int64) time.Time, into *time.Time)
 	return nil
 }
 
+func zeroSafeUnix(t time.Time, method func(time.Time) int64) int64 {
+	if t.IsZero() {
+		return 0
+	}
+	return method(t)
+}
+
 var _ sql.Scanner = &UnixMilli{}
 var _ driver.Valuer = UnixMilli{}
 
@@ -65,9 +72,6 @@ type UnixMilli struct {
 }
 
 func (um UnixMilli) MarshalJSON() ([]byte, error) {
-	if um.IsZero() {
-		return []byte{'0'}, nil
-	}
 	return json.Marshal(um.UnixMilli())
 }
 
@@ -83,6 +87,11 @@ func (um *UnixMilli) Scan(src any) error {
 	return anyIntegerToTime(src, time.UnixMilli, &um.Time)
 }
 
+func (um UnixMilli) Unix() int64      { return zeroSafeUnix(um.Time, time.Time.Unix) }
+func (um UnixMilli) UnixMilli() int64 { return zeroSafeUnix(um.Time, time.Time.UnixMilli) }
+func (um UnixMilli) UnixMicro() int64 { return zeroSafeUnix(um.Time, time.Time.UnixMicro) }
+func (um UnixMilli) UnixNano() int64  { return zeroSafeUnix(um.Time, time.Time.UnixNano) }
+
 var _ sql.Scanner = &UnixMicro{}
 var _ driver.Valuer = UnixMicro{}
 
@@ -91,9 +100,6 @@ type UnixMicro struct {
 }
 
 func (um UnixMicro) MarshalJSON() ([]byte, error) {
-	if um.IsZero() {
-		return []byte{'0'}, nil
-	}
 	return json.Marshal(um.UnixMicro())
 }
 
@@ -109,6 +115,11 @@ func (um *UnixMicro) Scan(src any) error {
 	return anyIntegerToTime(src, time.UnixMicro, &um.Time)
 }
 
+func (um UnixMicro) Unix() int64      { return zeroSafeUnix(um.Time, time.Time.Unix) }
+func (um UnixMicro) UnixMilli() int64 { return zeroSafeUnix(um.Time, time.Time.UnixMilli) }
+func (um UnixMicro) UnixMicro() int64 { return zeroSafeUnix(um.Time, time.Time.UnixMicro) }
+func (um UnixMicro) UnixNano() int64  { return zeroSafeUnix(um.Time, time.Time.UnixNano) }
+
 var _ sql.Scanner = &UnixNano{}
 var _ driver.Valuer = UnixNano{}
 
@@ -117,9 +128,6 @@ type UnixNano struct {
 }
 
 func (un UnixNano) MarshalJSON() ([]byte, error) {
-	if un.IsZero() {
-		return []byte{'0'}, nil
-	}
 	return json.Marshal(un.UnixNano())
 }
 
@@ -139,14 +147,16 @@ func (un *UnixNano) Scan(src any) error {
 	}, &un.Time)
 }
 
+func (un UnixNano) Unix() int64      { return zeroSafeUnix(un.Time, time.Time.Unix) }
+func (un UnixNano) UnixMilli() int64 { return zeroSafeUnix(un.Time, time.Time.UnixMilli) }
+func (un UnixNano) UnixMicro() int64 { return zeroSafeUnix(un.Time, time.Time.UnixMicro) }
+func (un UnixNano) UnixNano() int64  { return zeroSafeUnix(un.Time, time.Time.UnixNano) }
+
 type Unix struct {
 	time.Time
 }
 
 func (u Unix) MarshalJSON() ([]byte, error) {
-	if u.IsZero() {
-		return []byte{'0'}, nil
-	}
 	return json.Marshal(u.Unix())
 }
 
@@ -168,3 +178,8 @@ func (u *Unix) Scan(src any) error {
 		return time.Unix(i, 0)
 	}, &u.Time)
 }
+
+func (u Unix) Unix() int64      { return zeroSafeUnix(u.Time, time.Time.Unix) }
+func (u Unix) UnixMilli() int64 { return zeroSafeUnix(u.Time, time.Time.UnixMilli) }
+func (u Unix) UnixMicro() int64 { return zeroSafeUnix(u.Time, time.Time.UnixMicro) }
+func (u Unix) UnixNano() int64  { return zeroSafeUnix(u.Time, time.Time.UnixNano) }

slidge_whatsapp/vendor/go.mau.fi/util/random/string.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Tulir Asokan
+// Copyright (c) 2025 Tulir Asokan
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -10,20 +10,52 @@ import (
 	"encoding/binary"
 	"hash/crc32"
 	"strings"
-	"unsafe"
+
+	"go.mau.fi/util/exbytes"
 )
 
 const letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
 
 // StringBytes generates a random string of the given length and returns it as a byte array.
 func StringBytes(n int) []byte {
+	return StringBytesCharset(n, letters)
+}
+
+// AppendSequence generates a random sequence of the given length using the given character set
+// and appends it to the given output slice.
+func AppendSequence[T any](n int, charset, output []T) []T {
+	if n <= 0 {
+		return output
+	}
+	if output == nil {
+		output = make([]T, 0, n)
+	}
+	// If risk of modulo bias is too high, use 32-bit integers as source instead of 16-bit.
+	if 65536%len(charset) < 200 {
+		input := Bytes(n * 2)
+		for i := 0; i < n; i++ {
+			output = append(output, charset[binary.BigEndian.Uint16(input[i*2:])%uint16(len(charset))])
+		}
+	} else {
+		input := Bytes(n * 4)
+		for i := 0; i < n; i++ {
+			output = append(output, charset[binary.BigEndian.Uint32(input[i*4:])%uint32(len(charset))])
+		}
+	}
+	return output
+}
+
+// StringBytesCharset generates a random string of the given length using the given character set and returns it as a byte array.
+// Note that the character set must be ASCII. For arbitrary Unicode, use [AppendSequence] with a `[]rune`.
+func StringBytesCharset(n int, charset string) []byte {
 	if n <= 0 {
 		return []byte{}
 	}
 	input := Bytes(n * 2)
 	for i := 0; i < n; i++ {
-		// Risk of modulo bias is only 2 in 65535, values between 0 and 65533 are uniformly distributed
-		input[i] = letters[binary.BigEndian.Uint16(input[i*2:])%uint16(len(letters))]
+		// The risk of modulo bias is (65536 % len(charset)) / 65536.
+		// For the default charset, that's 2 in 65536 or 0.003 %.
+		input[i] = charset[binary.BigEndian.Uint16(input[i*2:])%uint16(len(charset))]
 	}
 	input = input[:n]
 	return input
@@ -34,8 +66,16 @@ func String(n int) string {
 	if n <= 0 {
 		return ""
 	}
-	str := StringBytes(n)
-	return *(*string)(unsafe.Pointer(&str))
+	return exbytes.UnsafeString(StringBytes(n))
+}
+
+// StringCharset generates a random string of the given length using the given character set.
+// Note that the character set must be ASCII. For arbitrary Unicode, use [AppendSequence] with a `[]rune`.
+func StringCharset(n int, charset string) string {
+	if n <= 0 {
+		return ""
+	}
+	return exbytes.UnsafeString(StringBytesCharset(n, charset))
 }
 
 func base62Encode(val uint32, minWidth int) []byte {
@@ -65,7 +105,7 @@ func Token(namespace string, randomLength int) string {
 	token[len(namespace)+randomLength+1] = '_'
 	checksum := base62Encode(crc32.ChecksumIEEE(token[:len(token)-7]), 6)
 	copy(token[len(token)-6:], checksum)
-	return *(*string)(unsafe.Pointer(&token))
+	return exbytes.UnsafeString(token)
 }
 
 // GetTokenPrefix parses the given token generated with Token, validates the checksum and returns the prefix namespace.

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

@@ -166,6 +166,7 @@ func (proc *Processor) decodeMutations(ctx context.Context, mutations []*waServe
 		out.Mutations = append(out.Mutations, Mutation{
 			Operation: mutation.GetOperation(),
 			Action:    syncAction.GetValue(),
+			Version:   syncAction.GetVersion(),
 			Index:     index,
 			IndexMAC:  indexMAC,
 			ValueMAC:  valueMAC,

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

@@ -45,7 +45,11 @@ func BuildMute(target types.JID, mute bool, muteDuration time.Duration) PatchInf
 	if muteDuration > 0 {
 		muteEndTimestamp = proto.Int64(time.Now().Add(muteDuration).UnixMilli())
 	}
+	return BuildMuteAbs(target, mute, muteEndTimestamp)
+}
 
+// BuildMuteAbs builds an app state patch for muting or unmuting a chat with an absolute timestamp.
+func BuildMuteAbs(target types.JID, mute bool, muteEndTimestamp *int64) PatchInfo {
 	return PatchInfo{
 		Type: WAPatchRegularHigh,
 		Mutations: []MutationInfo{{
@@ -89,30 +93,18 @@ func BuildPin(target types.JID, pin bool) PatchInfo {
 //
 // Archiving a chat will also unpin it automatically.
 func BuildArchive(target types.JID, archive bool, lastMessageTimestamp time.Time, lastMessageKey *waCommon.MessageKey) PatchInfo {
-	if lastMessageTimestamp.IsZero() {
-		lastMessageTimestamp = time.Now()
-	}
 	archiveMutationInfo := MutationInfo{
 		Index:   []string{IndexArchive, target.String()},
 		Version: 3,
 		Value: &waSyncAction.SyncActionValue{
 			ArchiveChatAction: &waSyncAction.ArchiveChatAction{
-				Archived: &archive,
-				MessageRange: &waSyncAction.SyncActionMessageRange{
-					LastMessageTimestamp: proto.Int64(lastMessageTimestamp.Unix()),
-					// TODO set LastSystemMessageTimestamp?
-				},
+				Archived:     &archive,
+				MessageRange: newMessageRange(lastMessageTimestamp, lastMessageKey),
+				// TODO set LastSystemMessageTimestamp?
 			},
 		},
 	}
 
-	if lastMessageKey != nil {
-		archiveMutationInfo.Value.ArchiveChatAction.MessageRange.Messages = []*waSyncAction.SyncActionMessage{{
-			Key:       lastMessageKey,
-			Timestamp: proto.Int64(lastMessageTimestamp.Unix()),
-		}}
-	}
-
 	mutations := []MutationInfo{archiveMutationInfo}
 	if archive {
 		mutations = append(mutations, newPinMutationInfo(target, false))
@@ -126,6 +118,25 @@ func BuildArchive(target types.JID, archive bool, lastMessageTimestamp time.Time
 	return result
 }
 
+// BuildMarkChatAsRead builds an app state patch for marking a chat as read or unread.
+func BuildMarkChatAsRead(target types.JID, read bool, lastMessageTimestamp time.Time, lastMessageKey *waCommon.MessageKey) PatchInfo {
+	action := &waSyncAction.MarkChatAsReadAction{
+		Read:         proto.Bool(read),
+		MessageRange: newMessageRange(lastMessageTimestamp, lastMessageKey),
+	}
+
+	return PatchInfo{
+		Type: WAPatchRegularLow,
+		Mutations: []MutationInfo{{
+			Index:   []string{IndexMarkChatAsRead, target.String()},
+			Version: 3,
+			Value: &waSyncAction.SyncActionValue{
+				MarkChatAsReadAction: action,
+			},
+		}},
+	}
+}
+
 func newLabelChatMutation(target types.JID, labelID string, labeled bool) MutationInfo {
 	return MutationInfo{
 		Index:   []string{IndexLabelAssociationChat, labelID, target.String()},
@@ -321,3 +332,37 @@ func (proc *Processor) EncodePatch(ctx context.Context, keyID []byte, state Hash
 
 	return result, nil
 }
+
+// BuildDeleteChat builds an app state patch for deleting a chat.
+func BuildDeleteChat(target types.JID, lastMessageTimestamp time.Time, lastMessageKey *waCommon.MessageKey) PatchInfo {
+	action := &waSyncAction.DeleteChatAction{
+		MessageRange: newMessageRange(lastMessageTimestamp, lastMessageKey),
+	}
+
+	return PatchInfo{
+		Type: WAPatchRegular,
+		Mutations: []MutationInfo{{
+			Index:   []string{IndexDeleteChat, target.String()},
+			Version: 6,
+			Value: &waSyncAction.SyncActionValue{
+				DeleteChatAction: action,
+			},
+		}},
+	}
+}
+
+func newMessageRange(lastMessageTimestamp time.Time, lastMessageKey *waCommon.MessageKey) *waSyncAction.SyncActionMessageRange {
+	if lastMessageTimestamp.IsZero() {
+		lastMessageTimestamp = time.Now()
+	}
+	messageRange := &waSyncAction.SyncActionMessageRange{
+		LastMessageTimestamp: proto.Int64(lastMessageTimestamp.Unix()),
+	}
+	if lastMessageKey != nil {
+		messageRange.Messages = []*waSyncAction.SyncActionMessage{{
+			Key:       lastMessageKey,
+			Timestamp: proto.Int64(lastMessageTimestamp.Unix()),
+		}}
+	}
+	return messageRange
+}

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

@@ -22,6 +22,7 @@ import (
 type Mutation struct {
 	Operation waServerSync.SyncdMutation_SyncdOperation
 	Action    *waSyncAction.SyncActionValue
+	Version   int32
 	Index     []string
 	IndexMAC  []byte
 	ValueMAC  []byte

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 {
@@ -348,13 +351,17 @@ func (cli *Client) requestAppStateKeys(ctx context.Context, rawKeyIDs [][]byte)
 	}
 }
 
-// SendAppState sends the given app state patch, then resyncs that app state type from the server
+// SendAppState sends the given app state patch, then triggers a background resync of that app state type
 // to update local caches and send events for the updates.
 //
 // You can use the Build methods in the appstate package to build the parameter for this method, e.g.
 //
 //	cli.SendAppState(ctx, appstate.BuildMute(targetJID, true, 24 * time.Hour))
 func (cli *Client) SendAppState(ctx context.Context, patch appstate.PatchInfo) error {
+	return cli.sendAppState(ctx, patch, false)
+}
+
+func (cli *Client) sendAppState(ctx context.Context, patch appstate.PatchInfo, waitForSync bool) error {
 	if cli == nil {
 		return ErrClientIsNil
 	}
@@ -409,5 +416,16 @@ func (cli *Client) SendAppState(ctx context.Context, patch appstate.PatchInfo) e
 		return fmt.Errorf("%w: %s", ErrAppStateUpdate, respCollection.XMLString())
 	}
 
-	return cli.FetchAppState(ctx, patch.Type, false, false)
+	if waitForSync {
+		return cli.FetchAppState(ctx, patch.Type, false, false)
+	}
+
+	go func() {
+		err := cli.FetchAppState(ctx, patch.Type, false, false)
+		if err != nil {
+			cli.Log.Errorf("Failed to resync app state %s after sending update: %v", patch.Type, err)
+		}
+	}()
+
+	return nil
 }

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

@@ -22,10 +22,11 @@ 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, protobufFailed bool) {
 	dec, err := decodeArmadillo(decrypted)
 	if err != nil {
 		cli.Log.Warnf("Failed to decode armadillo message from %s: %v", info.SourceString(), err)
+		protobufFailed = true
 		return
 	}
 	dec.Info = *info
@@ -41,7 +42,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
 	}
 }