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/download.go

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/base64"
@@ -129,21 +130,23 @@ var mediaTypeToMMSType = map[MediaType]string{
 }
 
 // DownloadAny loops through the downloadable parts of the given message and downloads the first non-nil item.
-func (cli *Client) DownloadAny(msg *waE2E.Message) (data []byte, err error) {
+//
+// Deprecated: it's recommended to find the specific message type you want to download manually and use the Download method instead.
+func (cli *Client) DownloadAny(ctx context.Context, msg *waE2E.Message) (data []byte, err error) {
 	if msg == nil {
 		return nil, ErrNothingDownloadableFound
 	}
 	switch {
 	case msg.ImageMessage != nil:
-		return cli.Download(msg.ImageMessage)
+		return cli.Download(ctx, msg.ImageMessage)
 	case msg.VideoMessage != nil:
-		return cli.Download(msg.VideoMessage)
+		return cli.Download(ctx, msg.VideoMessage)
 	case msg.AudioMessage != nil:
-		return cli.Download(msg.AudioMessage)
+		return cli.Download(ctx, msg.AudioMessage)
 	case msg.DocumentMessage != nil:
-		return cli.Download(msg.DocumentMessage)
+		return cli.Download(ctx, msg.DocumentMessage)
 	case msg.StickerMessage != nil:
-		return cli.Download(msg.StickerMessage)
+		return cli.Download(ctx, msg.StickerMessage)
 	default:
 		return nil, ErrNothingDownloadableFound
 	}
@@ -160,6 +163,10 @@ func getSize(msg DownloadableMessage) int {
 	}
 }
 
+// ReturnDownloadWarnings controls whether the Download function returns non-fatal validation warnings.
+// Currently, these include [ErrFileLengthMismatch] and [ErrInvalidMediaSHA256].
+var ReturnDownloadWarnings = true
+
 // DownloadThumbnail downloads a thumbnail from a message.
 //
 // This is primarily intended for downloading link preview thumbnails, which are in ExtendedTextMessage:
@@ -167,12 +174,12 @@ func getSize(msg DownloadableMessage) int {
 //	var msg *waE2E.Message
 //	...
 //	thumbnailImageBytes, err := cli.DownloadThumbnail(msg.GetExtendedTextMessage())
-func (cli *Client) DownloadThumbnail(msg DownloadableThumbnail) ([]byte, error) {
+func (cli *Client) DownloadThumbnail(ctx context.Context, msg DownloadableThumbnail) ([]byte, error) {
 	mediaType, ok := classToThumbnailMediaType[msg.ProtoReflect().Descriptor().Name()]
 	if !ok {
 		return nil, fmt.Errorf("%w '%s'", ErrUnknownMediaType, string(msg.ProtoReflect().Descriptor().Name()))
 	} else if len(msg.GetThumbnailDirectPath()) > 0 {
-		return cli.DownloadMediaWithPath(msg.GetThumbnailDirectPath(), msg.GetThumbnailEncSHA256(), msg.GetThumbnailSHA256(), msg.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType])
+		return cli.DownloadMediaWithPath(ctx, msg.GetThumbnailDirectPath(), msg.GetThumbnailEncSHA256(), msg.GetThumbnailSHA256(), msg.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType])
 	} else {
 		return nil, ErrNoURLPresent
 	}
@@ -200,7 +207,7 @@ func GetMediaType(msg DownloadableMessage) MediaType {
 //	imageData, err := cli.Download(msg.GetImageMessage())
 //
 // You can also use DownloadAny to download the first non-nil sub-message.
-func (cli *Client) Download(msg DownloadableMessage) ([]byte, error) {
+func (cli *Client) Download(ctx context.Context, msg DownloadableMessage) ([]byte, error) {
 	if cli == nil {
 		return nil, ErrClientIsNil
 	}
@@ -216,9 +223,9 @@ func (cli *Client) Download(msg DownloadableMessage) ([]byte, error) {
 		isWebWhatsappNetURL = strings.HasPrefix(url, "https://web.whatsapp.net")
 	}
 	if len(url) > 0 && !isWebWhatsappNetURL {
-		return cli.downloadAndDecrypt(url, msg.GetMediaKey(), mediaType, getSize(msg), msg.GetFileEncSHA256(), msg.GetFileSHA256())
+		return cli.downloadAndDecrypt(ctx, url, msg.GetMediaKey(), mediaType, getSize(msg), msg.GetFileEncSHA256(), msg.GetFileSHA256())
 	} else if len(msg.GetDirectPath()) > 0 {
-		return cli.DownloadMediaWithPath(msg.GetDirectPath(), msg.GetFileEncSHA256(), msg.GetFileSHA256(), msg.GetMediaKey(), getSize(msg), mediaType, mediaTypeToMMSType[mediaType])
+		return cli.DownloadMediaWithPath(ctx, msg.GetDirectPath(), msg.GetFileEncSHA256(), msg.GetFileSHA256(), msg.GetMediaKey(), getSize(msg), mediaType, mediaTypeToMMSType[mediaType])
 	} else {
 		if isWebWhatsappNetURL {
 			cli.Log.Warnf("Got a media message with a web.whatsapp.net URL (%s) and no direct path", url)
@@ -227,14 +234,25 @@ func (cli *Client) Download(msg DownloadableMessage) ([]byte, error) {
 	}
 }
 
-func (cli *Client) DownloadFB(transport *waMediaTransport.WAMediaTransport_Integral, mediaType MediaType) ([]byte, error) {
-	return cli.DownloadMediaWithPath(transport.GetDirectPath(), transport.GetFileEncSHA256(), transport.GetFileSHA256(), transport.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType])
+func (cli *Client) DownloadFB(
+	ctx context.Context,
+	transport *waMediaTransport.WAMediaTransport_Integral,
+	mediaType MediaType,
+) ([]byte, error) {
+	return cli.DownloadMediaWithPath(ctx, transport.GetDirectPath(), transport.GetFileEncSHA256(), transport.GetFileSHA256(), transport.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType])
 }
 
 // DownloadMediaWithPath downloads an attachment by manually specifying the path and encryption details.
-func (cli *Client) DownloadMediaWithPath(directPath string, encFileHash, fileHash, mediaKey []byte, fileLength int, mediaType MediaType, mmsType string) (data []byte, err error) {
+func (cli *Client) DownloadMediaWithPath(
+	ctx context.Context,
+	directPath string,
+	encFileHash, fileHash, mediaKey []byte,
+	fileLength int,
+	mediaType MediaType,
+	mmsType string,
+) (data []byte, err error) {
 	var mediaConn *MediaConn
-	mediaConn, err = cli.refreshMediaConn(false)
+	mediaConn, err = cli.refreshMediaConn(ctx, false)
 	if err != nil {
 		return nil, fmt.Errorf("failed to refresh media connections: %w", err)
 	}
@@ -244,9 +262,14 @@ func (cli *Client) DownloadMediaWithPath(directPath string, encFileHash, fileHas
 	for i, host := range mediaConn.Hosts {
 		// TODO omit hash for unencrypted media?
 		mediaURL := fmt.Sprintf("https://%s%s&hash=%s&mms-type=%s&__wa-mms=", host.Hostname, directPath, base64.URLEncoding.EncodeToString(encFileHash), mmsType)
-		data, err = cli.downloadAndDecrypt(mediaURL, mediaKey, mediaType, fileLength, encFileHash, fileHash)
-		if err == nil || errors.Is(err, ErrFileLengthMismatch) || errors.Is(err, ErrInvalidMediaSHA256) ||
-			errors.Is(err, ErrMediaDownloadFailedWith403) || errors.Is(err, ErrMediaDownloadFailedWith404) || errors.Is(err, ErrMediaDownloadFailedWith410) {
+		data, err = cli.downloadAndDecrypt(ctx, mediaURL, mediaKey, mediaType, fileLength, encFileHash, fileHash)
+		if err == nil ||
+			errors.Is(err, ErrFileLengthMismatch) ||
+			errors.Is(err, ErrInvalidMediaSHA256) ||
+			errors.Is(err, ErrMediaDownloadFailedWith403) ||
+			errors.Is(err, ErrMediaDownloadFailedWith404) ||
+			errors.Is(err, ErrMediaDownloadFailedWith410) ||
+			errors.Is(err, context.Canceled) {
 			return
 		} else if i >= len(mediaConn.Hosts)-1 {
 			return nil, fmt.Errorf("failed to download media from last host: %w", err)
@@ -256,10 +279,18 @@ func (cli *Client) DownloadMediaWithPath(directPath string, encFileHash, fileHas
 	return
 }
 
-func (cli *Client) downloadAndDecrypt(url string, mediaKey []byte, appInfo MediaType, fileLength int, fileEncSHA256, fileSHA256 []byte) (data []byte, err error) {
+func (cli *Client) downloadAndDecrypt(
+	ctx context.Context,
+	url string,
+	mediaKey []byte,
+	appInfo MediaType,
+	fileLength int,
+	fileEncSHA256,
+	fileSHA256 []byte,
+) (data []byte, err error) {
 	iv, cipherKey, macKey, _ := getMediaKeys(mediaKey, appInfo)
 	var ciphertext, mac []byte
-	if ciphertext, mac, err = cli.downloadPossiblyEncryptedMediaWithRetries(url, fileEncSHA256); err != nil {
+	if ciphertext, mac, err = cli.downloadPossiblyEncryptedMediaWithRetries(ctx, url, fileEncSHA256); err != nil {
 
 	} else if mediaKey == nil && fileEncSHA256 == nil && mac == nil {
 		// Unencrypted media, just return the downloaded data
@@ -268,10 +299,12 @@ func (cli *Client) downloadAndDecrypt(url string, mediaKey []byte, appInfo Media
 
 	} else if data, err = cbcutil.Decrypt(cipherKey, iv, ciphertext); err != nil {
 		err = fmt.Errorf("failed to decrypt file: %w", err)
-	} else if fileLength >= 0 && len(data) != fileLength {
-		err = fmt.Errorf("%w: expected %d, got %d", ErrFileLengthMismatch, fileLength, len(data))
-	} else if len(fileSHA256) == 32 && sha256.Sum256(data) != *(*[32]byte)(fileSHA256) {
-		err = ErrInvalidMediaSHA256
+	} else if ReturnDownloadWarnings {
+		if fileLength >= 0 && len(data) != fileLength {
+			err = fmt.Errorf("%w: expected %d, got %d", ErrFileLengthMismatch, fileLength, len(data))
+		} else if len(fileSHA256) == 32 && sha256.Sum256(data) != *(*[32]byte)(fileSHA256) {
+			err = ErrInvalidMediaSHA256
+		}
 	}
 	return
 }
@@ -282,6 +315,9 @@ func getMediaKeys(mediaKey []byte, appInfo MediaType) (iv, cipherKey, macKey, re
 }
 
 func shouldRetryMediaDownload(err error) bool {
+	if errors.Is(err, context.Canceled) {
+		return false
+	}
 	var netErr net.Error
 	var httpErr DownloadHTTPError
 	return errors.As(err, &netErr) ||
@@ -289,12 +325,12 @@ func shouldRetryMediaDownload(err error) bool {
 		(errors.As(err, &httpErr) && retryafter.Should(httpErr.StatusCode, true))
 }
 
-func (cli *Client) downloadPossiblyEncryptedMediaWithRetries(url string, checksum []byte) (file, mac []byte, err error) {
+func (cli *Client) downloadPossiblyEncryptedMediaWithRetries(ctx context.Context, url string, checksum []byte) (file, mac []byte, err error) {
 	for retryNum := 0; retryNum < 5; retryNum++ {
 		if checksum == nil {
-			file, err = cli.downloadMedia(url)
+			file, err = cli.downloadMedia(ctx, url)
 		} else {
-			file, mac, err = cli.downloadEncryptedMedia(url, checksum)
+			file, mac, err = cli.downloadEncryptedMedia(ctx, url, checksum)
 		}
 		if err == nil || !shouldRetryMediaDownload(err) {
 			return
@@ -305,13 +341,17 @@ func (cli *Client) downloadPossiblyEncryptedMediaWithRetries(url string, checksu
 			retryDuration = retryafter.Parse(httpErr.Response.Header.Get("Retry-After"), retryDuration)
 		}
 		cli.Log.Warnf("Failed to download media due to network error: %v, retrying in %s...", err, retryDuration)
-		time.Sleep(retryDuration)
+		select {
+		case <-ctx.Done():
+			return nil, nil, ctx.Err()
+		case <-time.After(retryDuration):
+		}
 	}
 	return
 }
 
-func (cli *Client) doMediaDownloadRequest(url string) (*http.Response, error) {
-	req, err := http.NewRequest(http.MethodGet, url, nil)
+func (cli *Client) doMediaDownloadRequest(ctx context.Context, url string) (*http.Response, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to prepare request: %w", err)
 	}
@@ -332,8 +372,8 @@ func (cli *Client) doMediaDownloadRequest(url string) (*http.Response, error) {
 	return resp, nil
 }
 
-func (cli *Client) downloadMedia(url string) ([]byte, error) {
-	resp, err := cli.doMediaDownloadRequest(url)
+func (cli *Client) downloadMedia(ctx context.Context, url string) ([]byte, error) {
+	resp, err := cli.doMediaDownloadRequest(ctx, url)
 	if err != nil {
 		return nil, err
 	}
@@ -344,8 +384,8 @@ func (cli *Client) downloadMedia(url string) ([]byte, error) {
 
 const mediaHMACLength = 10
 
-func (cli *Client) downloadEncryptedMedia(url string, checksum []byte) (file, mac []byte, err error) {
-	data, err := cli.downloadMedia(url)
+func (cli *Client) downloadEncryptedMedia(ctx context.Context, url string, checksum []byte) (file, mac []byte, err error) {
+	data, err := cli.downloadMedia(ctx, url)
 	if err != nil {
 		return
 	} else if len(data) <= mediaHMACLength {

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

@@ -141,6 +141,7 @@ var (
 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")
 	ErrNotPollUpdateMessage          = errors.New("given message isn't a poll update message")
 )
 

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

@@ -13,6 +13,7 @@ import (
 	"strings"
 
 	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/store"
 	"go.mau.fi/whatsmeow/types"
 	"go.mau.fi/whatsmeow/types/events"
 )
@@ -548,27 +549,43 @@ func (cli *Client) getGroupInfo(ctx context.Context, jid types.JID, lockParticip
 		return groupInfo, err
 	}
 	if lockParticipantCache {
-		cli.groupParticipantsCacheLock.Lock()
-		defer cli.groupParticipantsCacheLock.Unlock()
+		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,
+	}
+	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)
 	}
-	cli.groupParticipantsCache[jid] = participants
 	return groupInfo, nil
 }
 
-func (cli *Client) getGroupMembers(ctx context.Context, jid types.JID) ([]types.JID, error) {
-	cli.groupParticipantsCacheLock.Lock()
-	defer cli.groupParticipantsCacheLock.Unlock()
-	if _, ok := cli.groupParticipantsCache[jid]; !ok {
-		_, err := cli.getGroupInfo(ctx, jid, false)
-		if err != nil {
-			return nil, err
-		}
+func (cli *Client) getCachedGroupData(ctx context.Context, jid types.JID) (*groupMetaCache, error) {
+	cli.groupCacheLock.Lock()
+	defer cli.groupCacheLock.Unlock()
+	if val, ok := cli.groupCache[jid]; ok {
+		return val, nil
+	}
+	_, err := cli.getGroupInfo(ctx, jid, false)
+	if err != nil {
+		return nil, err
 	}
-	return cli.groupParticipantsCache[jid], nil
+	return cli.groupCache[jid], nil
 }
 
 func parseParticipant(childAG *waBinary.AttrUtility, child *waBinary.Node) types.GroupParticipant {
@@ -577,12 +594,14 @@ func parseParticipant(childAG *waBinary.AttrUtility, child *waBinary.Node) types
 		IsAdmin:      pcpType == "admin" || pcpType == "superadmin",
 		IsSuperAdmin: pcpType == "superadmin",
 		JID:          childAG.JID("jid"),
-		LID:          childAG.OptionalJIDOrEmpty("lid"),
 		DisplayName:  childAG.OptionalString("display_name"),
 	}
-	if participant.JID.Server == types.HiddenUserServer && participant.LID.IsEmpty() {
+	if participant.JID.Server == types.HiddenUserServer {
 		participant.LID = participant.JID
-		//participant.JID = types.EmptyJID
+		participant.PhoneNumber = childAG.OptionalJIDOrEmpty("phone_number")
+	} else if participant.JID.Server == types.DefaultUserServer {
+		participant.PhoneNumber = participant.JID
+		participant.LID = childAG.OptionalJIDOrEmpty("lid")
 	}
 	if errorCode := childAG.OptionalInt("error"); errorCode != 0 {
 		participant.Error = errorCode
@@ -604,15 +623,19 @@ func (cli *Client) parseGroupNode(groupNode *waBinary.Node) (*types.GroupInfo, e
 
 	group.JID = types.NewJID(ag.String("id"), types.GroupServer)
 	group.OwnerJID = ag.OptionalJIDOrEmpty("creator")
+	group.OwnerPN = ag.OptionalJIDOrEmpty("creator_pn")
 
 	group.Name = ag.String("subject")
 	group.NameSetAt = ag.UnixTime("s_t")
 	group.NameSetBy = ag.OptionalJIDOrEmpty("s_o")
+	group.NameSetByPN = ag.OptionalJIDOrEmpty("s_o_pn")
 
 	group.GroupCreated = ag.UnixTime("creation")
+	group.CreatorCountryCode = ag.OptionalString("creator_country_code")
 
 	group.AnnounceVersionID = ag.OptionalString("a_v_id")
 	group.ParticipantVersionID = ag.OptionalString("p_v_id")
+	group.AddressingMode = types.AddressingMode(ag.OptionalString("addressing_mode"))
 
 	for _, child := range groupNode.GetChildren() {
 		childAG := child.AttrGetter()
@@ -626,6 +649,7 @@ func (cli *Client) parseGroupNode(groupNode *waBinary.Node) (*types.GroupInfo, e
 				group.Topic = string(topicBytes)
 				group.TopicID = childAG.String("id")
 				group.TopicSetBy = childAG.OptionalJIDOrEmpty("participant")
+				group.TopicSetByPN = childAG.OptionalJIDOrEmpty("participant_pn") // TODO confirm field name
 				group.TopicSetAt = childAG.UnixTime("t")
 			}
 		case "announcement":
@@ -691,16 +715,20 @@ func parseParticipantList(node *waBinary.Node) (participants []types.JID) {
 	return
 }
 
-func (cli *Client) parseGroupCreate(node *waBinary.Node) (*events.JoinedGroup, error) {
+func (cli *Client) parseGroupCreate(parentNode, node *waBinary.Node) (*events.JoinedGroup, error) {
 	groupNode, ok := node.GetOptionalChildByTag("group")
 	if !ok {
 		return nil, fmt.Errorf("group create notification didn't contain group info")
 	}
 	var evt events.JoinedGroup
+	pag := parentNode.AttrGetter()
 	ag := node.AttrGetter()
 	evt.Reason = ag.OptionalString("reason")
 	evt.CreateKey = ag.OptionalString("key")
 	evt.Type = ag.OptionalString("type")
+	evt.Sender = pag.OptionalJID("participant")
+	evt.SenderPN = pag.OptionalJID("participant_pn")
+	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)
@@ -715,6 +743,7 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 	evt.JID = ag.JID("from")
 	evt.Notify = ag.OptionalString("notify")
 	evt.Sender = ag.OptionalJID("participant")
+	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())
@@ -723,8 +752,8 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 	for _, child := range node.GetChildren() {
 		cag := child.AttrGetter()
 		if child.Tag == "add" || child.Tag == "remove" || child.Tag == "promote" || child.Tag == "demote" {
-			evt.PrevParticipantVersionID = cag.String("prev_v_id")
-			evt.ParticipantVersionID = cag.String("v_id")
+			evt.PrevParticipantVersionID = cag.OptionalString("prev_v_id")
+			evt.ParticipantVersionID = cag.OptionalString("v_id")
 		}
 		switch child.Tag {
 		case "add":
@@ -744,9 +773,10 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 			evt.Delete = &types.GroupDelete{Deleted: true, DeleteReason: cag.String("reason")}
 		case "subject":
 			evt.Name = &types.GroupName{
-				Name:      cag.String("subject"),
-				NameSetAt: cag.UnixTime("s_t"),
-				NameSetBy: cag.OptionalJIDOrEmpty("s_o"),
+				Name:        cag.String("subject"),
+				NameSetAt:   cag.UnixTime("s_t"),
+				NameSetBy:   cag.OptionalJIDOrEmpty("s_o"),
+				NameSetByPN: cag.OptionalJIDOrEmpty("s_o_pn"),
 			}
 		case "description":
 			var topicStr string
@@ -833,40 +863,40 @@ func (cli *Client) parseGroupChange(node *waBinary.Node) (*events.GroupInfo, err
 }
 
 func (cli *Client) updateGroupParticipantCache(evt *events.GroupInfo) {
+	// TODO can the addressing mode change here?
 	if len(evt.Join) == 0 && len(evt.Leave) == 0 {
 		return
 	}
-	cli.groupParticipantsCacheLock.Lock()
-	defer cli.groupParticipantsCacheLock.Unlock()
-	cached, ok := cli.groupParticipantsCache[evt.JID]
+	cli.groupCacheLock.Lock()
+	defer cli.groupCacheLock.Unlock()
+	cached, ok := cli.groupCache[evt.JID]
 	if !ok {
 		return
 	}
 Outer:
 	for _, jid := range evt.Join {
-		for _, existingJID := range cached {
+		for _, existingJID := range cached.Members {
 			if jid == existingJID {
 				continue Outer
 			}
 		}
-		cached = append(cached, jid)
+		cached.Members = append(cached.Members, jid)
 	}
 	for _, jid := range evt.Leave {
-		for i, existingJID := range cached {
+		for i, existingJID := range cached.Members {
 			if existingJID == jid {
-				cached[i] = cached[len(cached)-1]
-				cached = cached[:len(cached)-1]
+				cached.Members[i] = cached.Members[len(cached.Members)-1]
+				cached.Members = cached.Members[:len(cached.Members)-1]
 				break
 			}
 		}
 	}
-	cli.groupParticipantsCache[evt.JID] = cached
 }
 
 func (cli *Client) parseGroupNotification(node *waBinary.Node) (any, error) {
 	children := node.GetChildren()
 	if len(children) == 1 && children[0].Tag == "create" {
-		return cli.parseGroupCreate(&children[0])
+		return cli.parseGroupCreate(node, &children[0])
 	} else {
 		groupChange, err := cli.parseGroupChange(node)
 		if err != nil {