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

slidge_whatsapp/config.py

@@ -21,6 +21,9 @@ DB_PATH__DOC = (
     "${SLIDGE_HOME_DIR}/whatsapp/whatsapp.db"
 )
 
+DB_PARAMS = "?_foreign_keys=true"
+DB_PARAMS__DOC = "Additional parameters to pass to database connection string."
+
 ALWAYS_SYNC_ROSTER = False
 ALWAYS_SYNC_ROSTER__DOC = (
     "Whether or not to perform a full sync of the WhatsApp roster on startup."

slidge_whatsapp/contact.py

@@ -2,6 +2,7 @@ from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
 from slidge import LegacyContact, LegacyRoster
+from slidge.util.types import Avatar
 from slixmpp.exceptions import XMPPError
 
 from . import config
@@ -28,6 +29,12 @@ class Contact(LegacyContact[str]):
         else:
             self.online(last_seen=last_seen)
 
+    async def update_info(self) -> None:
+        if whatsapp.IsAnonymousJID(self.legacy_id):
+            self.log.error(
+                "Contact for anonymous participant added: %s", self.legacy_id
+            )
+
 
 class Roster(LegacyRoster[str, Contact]):
     session: "Session"
@@ -54,9 +61,12 @@ class Roster(LegacyRoster[str, Contact]):
         contact.name = data.Name
         contact.is_friend = True
         try:
-            avatar = self.session.whatsapp.GetAvatar(data.JID, contact.avatar or "")
-            if avatar.URL and contact.avatar != avatar.ID:
-                await contact.set_avatar(avatar.URL, avatar.ID)
+            unique_id = ""
+            if contact.avatar is not None:
+                unique_id = contact.avatar.unique_id or ""
+            avatar = self.session.whatsapp.GetAvatar(data.JID, unique_id)
+            if avatar.URL and unique_id != avatar.ID:
+                await contact.set_avatar(Avatar(url=avatar.URL, unique_id=avatar.ID))
             elif avatar.URL == "" and avatar.ID == "":
                 await contact.set_avatar(None)
         except RuntimeError as err:
@@ -67,6 +77,8 @@ class Roster(LegacyRoster[str, Contact]):
         return contact
 
     async def legacy_id_to_jid_username(self, legacy_id: str) -> str:
+        if not "@" in legacy_id:
+            raise XMPPError("item-not-found", "Invalid contact ID, not a JID")
         return "+" + legacy_id[: legacy_id.find("@")]
 
     async def jid_username_to_legacy_id(self, jid_username: str) -> str:

slidge_whatsapp/event.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"fmt"
 	"mime"
+	"slices"
 	"strings"
 
 	// Internal packages.
@@ -45,6 +46,7 @@ type EventPayload struct {
 	QRCode       string
 	PairDeviceID string
 	Connect      Connect
+	LoggedOut    LoggedOut
 	Contact      Contact
 	Presence     Presence
 	Message      Message
@@ -65,6 +67,11 @@ type Connect struct {
 	Error string // The connection error, if any.
 }
 
+// LoggedOut repreents event data related to an explicit or implicit log-out event.
+type LoggedOut struct {
+	Reason string // The human-readable reason for logging out, if any.
+}
+
 // A Avatar represents a small image set for a Contact or Group.
 type Avatar struct {
 	ID  string // The unique ID for this avatar, used for persistent caching.
@@ -81,10 +88,25 @@ type Contact struct {
 // NewContactEvent returns event data meant for [Session.propagateEvent] for the contact information
 // given. Unknown or invalid contact information will return an [EventUnknown] event with nil data.
 func newContactEvent(jid types.JID, info types.ContactInfo) (EventKind, *EventPayload) {
-	var contact = Contact{
-		JID: jid.ToNonAD().String(),
+	contact := newContact(jid, info)
+	if contact.JID == "" {
+		return EventUnknown, nil
+	}
+
+	return EventContact, &EventPayload{Contact: contact}
+}
+
+// NewContact returns a concrete [Contact] instance for the JID and additional information given.
+// In cases where a valid contact can't be returned, [Contact.JID] will be left empty.
+func newContact(jid types.JID, info types.ContactInfo) Contact {
+	// Don't instantiate hidden contacts, as these are better handled as group participants
+	if jid.Server == types.HiddenUserServer {
+		return Contact{}
 	}
 
+	// Find valid contact name from list of alternatives, or return empty contact if none could
+	// be found.
+	var contact = Contact{JID: jid.ToNonAD().String()}
 	for _, n := range []string{info.FullName, info.FirstName, info.BusinessName, info.PushName} {
 		if n != "" {
 			contact.Name = n
@@ -92,12 +114,11 @@ func newContactEvent(jid types.JID, info types.ContactInfo) (EventKind, *EventPa
 		}
 	}
 
-	// Don't attempt to synchronize contacts with no user-readable name.
 	if contact.Name == "" {
-		return EventUnknown, nil
+		return Contact{}
 	}
 
-	return EventContact, &EventPayload{Contact: contact}
+	return contact
 }
 
 // PresenceKind represents the different kinds of activity states possible in WhatsApp.
@@ -121,6 +142,10 @@ type Presence struct {
 // NewPresenceEvent returns event data meant for [Session.propagateEvent] for the primitive presence
 // event given.
 func newPresenceEvent(evt *events.Presence) (EventKind, *EventPayload) {
+	if evt.From.Server == types.HiddenUserServer {
+		return EventUnknown, nil
+	}
+
 	var presence = Presence{
 		JID:      evt.From.ToNonAD().String(),
 		Kind:     PresenceAvailable,
@@ -168,9 +193,11 @@ type Message struct {
 	Location    Location     // The location metadata for messages, if any.
 	Poll        Poll         // The multiple-choice poll contained in the message, if any.
 	Album       Album        // The image album message, if any.
+	GroupInvite Group        // Group information for the invite group included in this message, if any.
 	MentionJIDs []string     // A list of JIDs mentioned in this message, if any.
 	Receipts    []Receipt    // The receipt statuses for the message, typically provided alongside historical messages.
 	Reactions   []Message    // Reactions attached to message, typically provided alongside historical messages.
+	IsHistory   bool         // Whether or not the message is derived from message history.
 }
 
 // A Attachment represents additional binary data (e.g. images, videos, documents) provided alongside
@@ -252,13 +279,13 @@ type Album struct {
 
 // NewMessageEvent returns event data meant for [Session.propagateEvent] for the primive message
 // event given. Unknown or invalid messages will return an [EventUnknown] event with nil data.
-func newMessageEvent(client *whatsmeow.Client, evt *events.Message) (EventKind, *EventPayload) {
+func newMessageEvent(ctx context.Context, client *whatsmeow.Client, evt *events.Message) (EventKind, *EventPayload) {
 	// Set basic data for message, to be potentially amended depending on the concrete version of
 	// the underlying message.
 	var message = Message{
 		Kind:      MessagePlain,
 		ID:        evt.Info.ID,
-		JID:       evt.Info.Sender.ToNonAD().String(),
+		JID:       getPreferredJID(ctx, client, evt.Info.Sender, evt.Info.SenderAlt).ToNonAD().String(),
 		Body:      evt.Message.GetConversation(),
 		Timestamp: evt.Info.Timestamp.Unix(),
 		IsCarbon:  evt.Info.IsFromMe,
@@ -358,7 +385,7 @@ func newMessageEvent(client *whatsmeow.Client, evt *events.Message) (EventKind,
 	}
 
 	// Handle message attachments, if any.
-	if attach, context, err := getMessageAttachments(client, evt.Message); err != nil {
+	if attach, context, err := getMessageAttachments(ctx, client, evt.Message); err != nil {
 		client.Log.Errorf("Failed getting message attachments: %s", err)
 		return EventUnknown, nil
 	} else if len(attach) > 0 {
@@ -376,7 +403,18 @@ func newMessageEvent(client *whatsmeow.Client, evt *events.Message) (EventKind,
 			message.Body = e.GetText()
 		}
 
-		message = getMessageWithContext(message, e.GetContextInfo())
+		// Handle group-chat invite link in text message.
+		if code, ok := strings.CutPrefix(e.GetMatchedText(), whatsmeow.InviteLinkPrefix); ok {
+			if info, err := client.GetGroupInfoFromLink(e.GetMatchedText()); err != nil {
+				client.Log.Errorf("Failed getting group info from invite: %s", err)
+			} else if _, err := client.JoinGroupWithLink(code); err != nil {
+				client.Log.Errorf("Failed joining group with invite: %s", err)
+			} else {
+				message.GroupInvite = newGroup(ctx, client, info)
+			}
+		} else {
+			message = getMessageWithContext(message, e.GetContextInfo())
+		}
 	}
 
 	// Ignore obviously invalid messages.
@@ -412,7 +450,7 @@ func getMessageWithContext(message Message, info *waE2E.ContextInfo) Message {
 
 // GetMessageAttachments fetches and decrypts attachments (images, audio, video, or documents) sent
 // via WhatsApp. Any failures in retrieving any attachment will return an error immediately.
-func getMessageAttachments(client *whatsmeow.Client, message *waE2E.Message) ([]Attachment, *waE2E.ContextInfo, error) {
+func getMessageAttachments(ctx context.Context, client *whatsmeow.Client, message *waE2E.Message) ([]Attachment, *waE2E.ContextInfo, error) {
 	var result []Attachment
 	var info *waE2E.ContextInfo
 	var convertSpec *media.Spec
@@ -422,6 +460,7 @@ func getMessageAttachments(client *whatsmeow.Client, message *waE2E.Message) ([]
 		message.GetVideoMessage(),
 		message.GetDocumentMessage(),
 		message.GetStickerMessage(),
+		message.GetPtvMessage(),
 	}
 
 	for _, msg := range kinds {
@@ -450,7 +489,7 @@ func getMessageAttachments(client *whatsmeow.Client, message *waE2E.Message) ([]
 		}
 
 		// Attempt to download and decrypt raw attachment data, if any.
-		data, err := client.Download(msg)
+		data, err := client.Download(ctx, msg)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -459,8 +498,10 @@ func getMessageAttachments(client *whatsmeow.Client, message *waE2E.Message) ([]
 
 		// Convert incoming data if a specification has been given, ignoring any errors that occur.
 		if convertSpec != nil {
-			data, err = media.Convert(context.Background(), a.Data, convertSpec)
-			if err == nil {
+			data, err = media.Convert(ctx, a.Data, convertSpec)
+			if err != nil {
+				client.Log.Warnf("failed to convert incoming attachment: %s", err)
+			} else {
 				a.Data, a.MIME = data, string(convertSpec.MIME)
 			}
 		}
@@ -557,7 +598,7 @@ var (
 //
 // If the input MIME type is unknown, or conversion is impossible, the given attachment is not
 // changed.
-func convertAttachment(attach *Attachment) error {
+func convertAttachment(ctx context.Context, attach *Attachment) error {
 	var detectedMIME media.MIMEType
 	if t := media.DetectMIMEType(attach.Data); t != media.TypeUnknown {
 		detectedMIME = t
@@ -567,8 +608,6 @@ func convertAttachment(attach *Attachment) error {
 	}
 
 	var spec media.Spec
-	var ctx = context.Background()
-
 	switch detectedMIME {
 	case media.TypePNG, media.TypeWebP:
 		// Convert common image formats to JPEG for inline preview.
@@ -648,6 +687,10 @@ func convertAttachment(attach *Attachment) error {
 	}
 
 	attach.Data, attach.MIME = data, string(spec.MIME)
+	if i := strings.LastIndexByte(attach.Filename, '.'); i != -1 {
+		attach.Filename = attach.Filename[:i] + extensionByType(attach.MIME)
+	}
+
 	return nil
 }
 
@@ -666,12 +709,10 @@ var knownMediaTypes = map[string]whatsmeow.MediaType{
 // type specified within. Attachments are handled as generic file uploads unless they're of a
 // specific format; in addition, certain MIME types may be automatically converted to a
 // well-supported type via FFmpeg (if available).
-func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Message, error) {
-	var ctx = context.Background()
+func uploadAttachment(ctx context.Context, client *whatsmeow.Client, attach *Attachment) (*waE2E.Message, error) {
 	var originalMIME = attach.MIME
-
-	if err := convertAttachment(attach); err != nil {
-		client.Log.Warnf("failed to auto-convert attachment: %s", err)
+	if err := convertAttachment(ctx, attach); err != nil {
+		client.Log.Warnf("failed to convert outgoing attachment: %s", err)
 	}
 
 	mediaType := knownMediaTypes[getBaseMediaType(attach.MIME)]
@@ -833,7 +874,7 @@ func getBaseMediaType(typ string) string {
 //
 // Typically, this will return [EventMessage] events with appropriate [Message] payloads; unknown or
 // invalid messages will return an [EventUnknown] event with nil data.
-func newEventFromHistory(client *whatsmeow.Client, info *waWeb.WebMessageInfo) (EventKind, *EventPayload) {
+func newEventFromHistory(ctx context.Context, client *whatsmeow.Client, info *waWeb.WebMessageInfo) (EventKind, *EventPayload) {
 	// Handle message as group message is remote JID is a group JID in the absence of any other,
 	// specific signal, or don't handle at all if no group JID is found.
 	var jid = info.GetKey().GetRemoteJID()
@@ -850,10 +891,15 @@ func newEventFromHistory(client *whatsmeow.Client, info *waWeb.WebMessageInfo) (
 		Body:      info.GetMessage().GetConversation(),
 		Timestamp: int64(info.GetMessageTimestamp()),
 		IsCarbon:  info.GetKey().GetFromMe(),
+		IsHistory: true,
 	}
 
 	if info.Participant != nil {
-		message.JID = info.GetParticipant()
+		jid, err := types.ParseJID(info.GetParticipant())
+		if err != nil {
+			return EventUnknown, nil
+		}
+		message.JID = getPreferredJID(ctx, client, jid).ToNonAD().String()
 	} else if info.GetKey().GetFromMe() {
 		message.JID = client.Store.ID.ToNonAD().String()
 	} else {
@@ -868,9 +914,13 @@ func newEventFromHistory(client *whatsmeow.Client, info *waWeb.WebMessageInfo) (
 	case waWeb.WebMessageInfo_CIPHERTEXT:
 		return EventUnknown, nil
 	case waWeb.WebMessageInfo_CALL_MISSED_VOICE, waWeb.WebMessageInfo_CALL_MISSED_VIDEO:
+		jid, err := types.ParseJID(info.GetKey().GetParticipant())
+		if err != nil {
+			return EventUnknown, nil
+		}
 		return EventCall, &EventPayload{Call: Call{
 			State:     CallMissed,
-			JID:       info.GetKey().GetRemoteJID(),
+			JID:       getPreferredJID(ctx, client, jid).ToNonAD().String(),
 			Timestamp: int64(info.GetMessageTimestamp()),
 		}}
 	case waWeb.WebMessageInfo_REVOKE:
@@ -886,10 +936,14 @@ func newEventFromHistory(client *whatsmeow.Client, info *waWeb.WebMessageInfo) (
 	// Handle emoji reaction to existing message.
 	for _, r := range info.GetReactions() {
 		if r.GetText() != "" {
+			jid, err := types.ParseJID(r.GetKey().GetParticipant())
+			if err != nil {
+				continue
+			}
 			message.Reactions = append(message.Reactions, Message{
 				Kind:      MessageReaction,
 				ID:        r.GetKey().GetID(),
-				JID:       r.GetKey().GetRemoteJID(),
+				JID:       getPreferredJID(ctx, client, jid).ToNonAD().String(),
 				Body:      r.GetText(),
 				Timestamp: r.GetSenderTimestampMS() / 1000,
 				IsCarbon:  r.GetKey().GetFromMe(),
@@ -898,7 +952,7 @@ func newEventFromHistory(client *whatsmeow.Client, info *waWeb.WebMessageInfo) (
 	}
 
 	// Handle message attachments, if any.
-	if attach, context, err := getMessageAttachments(client, info.GetMessage()); err != nil {
+	if attach, context, err := getMessageAttachments(ctx, client, info.GetMessage()); err != nil {
 		client.Log.Errorf("Failed getting message attachments: %s", err)
 		return EventUnknown, nil
 	} else if len(attach) > 0 {
@@ -915,7 +969,15 @@ func newEventFromHistory(client *whatsmeow.Client, info *waWeb.WebMessageInfo) (
 		if client.Store.ID.ToNonAD().String() == r.GetUserJID() {
 			continue
 		}
-		var receipt = Receipt{MessageIDs: []string{message.ID}, JID: r.GetUserJID(), GroupJID: message.GroupJID}
+		jid, err := types.ParseJID(r.GetUserJID())
+		if err != nil {
+			continue
+		}
+		var receipt = Receipt{
+			JID:        getPreferredJID(ctx, client, jid).ToNonAD().String(),
+			GroupJID:   message.GroupJID,
+			MessageIDs: []string{message.ID},
+		}
 		switch info.GetStatus() {
 		case waWeb.WebMessageInfo_DELIVERY_ACK:
 			receipt.Kind = ReceiptDelivered
@@ -933,7 +995,6 @@ func newEventFromHistory(client *whatsmeow.Client, info *waWeb.WebMessageInfo) (
 		if message.Body == "" {
 			message.Body = e.GetText()
 		}
-
 		message = getMessageWithContext(message, e.GetContextInfo())
 	}
 
@@ -966,10 +1027,12 @@ type ChatState struct {
 
 // NewChatStateEvent returns event data meant for [Session.propagateEvent] for the primitive
 // chat-state event given.
-func newChatStateEvent(evt *events.ChatPresence) (EventKind, *EventPayload) {
-	var state = ChatState{JID: evt.MessageSource.Sender.ToNonAD().String()}
-	if evt.MessageSource.IsGroup {
-		state.GroupJID = evt.MessageSource.Chat.ToNonAD().String()
+func newChatStateEvent(ctx context.Context, client *whatsmeow.Client, evt *events.ChatPresence) (EventKind, *EventPayload) {
+	var state = ChatState{
+		JID: getPreferredJID(ctx, client, evt.Sender, evt.SenderAlt).ToNonAD().String(),
+	}
+	if evt.IsGroup {
+		state.GroupJID = evt.Chat.ToNonAD().String()
 	}
 	switch evt.State {
 	case types.ChatPresenceComposing:
@@ -1004,24 +1067,24 @@ type Receipt struct {
 
 // NewReceiptEvent returns event data meant for [Session.propagateEvent] for the primive receipt
 // event given. Unknown or invalid receipts will return an [EventUnknown] event with nil data.
-func newReceiptEvent(evt *events.Receipt) (EventKind, *EventPayload) {
+func newReceiptEvent(ctx context.Context, client *whatsmeow.Client, evt *events.Receipt) (EventKind, *EventPayload) {
 	var receipt = Receipt{
-		MessageIDs: append([]string{}, evt.MessageIDs...),
-		JID:        evt.MessageSource.Sender.ToNonAD().String(),
+		MessageIDs: slices.Clone(evt.MessageIDs),
+		JID:        getPreferredJID(ctx, client, evt.Sender, evt.SenderAlt).ToNonAD().String(),
 		Timestamp:  evt.Timestamp.Unix(),
-		IsCarbon:   evt.MessageSource.IsFromMe,
+		IsCarbon:   evt.IsFromMe,
 	}
 
 	if len(receipt.MessageIDs) == 0 {
 		return EventUnknown, nil
 	}
 
-	if evt.MessageSource.Chat.Server == types.BroadcastServer {
-		receipt.JID = evt.MessageSource.BroadcastListOwner.ToNonAD().String()
-	} else if evt.MessageSource.IsGroup {
-		receipt.GroupJID = evt.MessageSource.Chat.ToNonAD().String()
+	if evt.Chat.Server == types.BroadcastServer {
+		receipt.JID = evt.BroadcastListOwner.ToNonAD().String()
+	} else if evt.IsGroup {
+		receipt.GroupJID = evt.Chat.ToNonAD().String()
 	} else if receipt.IsCarbon {
-		receipt.JID = evt.MessageSource.Chat.ToNonAD().String()
+		receipt.JID = evt.Chat.ToNonAD().String()
 	}
 
 	switch evt.Type {
@@ -1054,14 +1117,15 @@ type Group struct {
 	Subject      GroupSubject       // The longer-form, user-defined description for this group.
 	Nickname     string             // Our own nickname in this group-chat.
 	Participants []GroupParticipant // The list of participant contacts for this group, including ourselves.
+	InviteCode   string             // The code for inviting members to this group-chat.
 }
 
 // A GroupSubject represents the user-defined group description and attached metadata thereof, for a
 // given [Group].
 type GroupSubject struct {
-	Subject  string // The user-defined group description.
-	SetAt    int64  // The exact time this group description was set at, as a timestamp.
-	SetByJID string // The JID of the user that set the subject.
+	Subject string // The user-defined group description.
+	SetAt   int64  // The exact time this group description was set at, as a timestamp.
+	SetBy   string // The name of the user that set the subject.
 }
 
 // GroupParticipantAction represents the distinct set of actions that can be taken when encountering
@@ -1091,10 +1155,11 @@ func (a GroupParticipantAction) toParticipantChange() whatsmeow.ParticipantChang
 }
 
 // A GroupParticipant represents a contact who is currently joined in a given group. Participants in
-// WhatsApp can always be derived back to their individual [Contact]; there are no anonymous groups
+// WhatsApp can generally be derived back to their individual [Contact]; there are no anonymous groups
 // in WhatsApp.
 type GroupParticipant struct {
 	JID         string                 // The WhatsApp JID for this participant.
+	Nickname    string                 // The user-set name for this participant, typically only set for anonymous participants.
 	Affiliation GroupAffiliation       // The set of priviledges given to this specific participant.
 	Action      GroupParticipantAction // The specific action to take for this participant; typically to add.
 }
@@ -1102,59 +1167,67 @@ type GroupParticipant struct {
 // NewGroupParticipant returns a [GroupParticipant], filling fields from the internal participant
 // type. This is a no-op if [types.GroupParticipant.Error] is non-zero, and other fields may only
 // be set optionally.
-func newGroupParticipant(p types.GroupParticipant) GroupParticipant {
-	if p.Error > 0 {
+func newGroupParticipant(ctx context.Context, client *whatsmeow.Client, participant types.GroupParticipant) GroupParticipant {
+	if participant.Error > 0 {
 		return GroupParticipant{}
 	}
-	var affiliation = GroupAffiliationNone
-	if p.IsSuperAdmin {
-		affiliation = GroupAffiliationOwner
-	} else if p.IsAdmin {
-		affiliation = GroupAffiliationAdmin
+	var jid = getPreferredJID(ctx, client, participant.JID, participant.PhoneNumber)
+	var p = GroupParticipant{
+		JID: jid.ToNonAD().String(),
+	}
+	if participant.IsSuperAdmin {
+		p.Affiliation = GroupAffiliationOwner
+	} else if participant.IsAdmin {
+		p.Affiliation = GroupAffiliationAdmin
 	}
-	return GroupParticipant{
-		JID:         p.JID.ToNonAD().String(),
-		Affiliation: affiliation,
+	if IsAnonymousJID(p.JID) {
+		if c, err := client.Store.Contacts.GetContact(ctx, participant.JID); err == nil {
+			p.Nickname = c.PushName
+		}
 	}
+	return p
 }
 
 // NewGroupEvent returns event data meant for [Session.propagateEvent] for the primive group event
 // given. Group data returned by this function can be partial, and callers should take care to only
 // handle non-empty values.
-func newGroupEvent(evt *events.GroupInfo) (EventKind, *EventPayload) {
+func newGroupEvent(ctx context.Context, client *whatsmeow.Client, evt *events.GroupInfo) (EventKind, *EventPayload) {
 	var group = Group{JID: evt.JID.ToNonAD().String()}
 	if evt.Name != nil {
 		group.Name = evt.Name.Name
 	}
 	if evt.Topic != nil {
+		topicJID := getPreferredJID(ctx, client, evt.Topic.TopicSetBy, evt.Topic.TopicSetByPN)
 		group.Subject = GroupSubject{
-			Subject:  evt.Topic.Topic,
-			SetAt:    evt.Topic.TopicSetAt.Unix(),
-			SetByJID: evt.Topic.TopicSetBy.ToNonAD().String(),
+			Subject: evt.Topic.Topic,
+			SetAt:   evt.Topic.TopicSetAt.Unix(),
+		}
+		if c, err := client.Store.Contacts.GetContact(ctx, topicJID); err == nil {
+			group.Subject.SetBy = c.PushName
 		}
 	}
 	for _, p := range evt.Join {
 		group.Participants = append(group.Participants, GroupParticipant{
-			JID:    p.ToNonAD().String(),
+			JID:    getPreferredJID(ctx, client, p).ToNonAD().String(),
 			Action: GroupParticipantActionAdd,
 		})
 	}
 	for _, p := range evt.Leave {
 		group.Participants = append(group.Participants, GroupParticipant{
-			JID:    p.ToNonAD().String(),
+			JID:    getPreferredJID(ctx, client, p).ToNonAD().String(),
 			Action: GroupParticipantActionRemove,
 		})
 	}
 	for _, p := range evt.Promote {
 		group.Participants = append(group.Participants, GroupParticipant{
-			JID:         p.ToNonAD().String(),
+			JID:         getPreferredJID(ctx, client, p).ToNonAD().String(),
 			Action:      GroupParticipantActionPromote,
 			Affiliation: GroupAffiliationAdmin,
 		})
 	}
 	for _, p := range evt.Demote {
 		group.Participants = append(group.Participants, GroupParticipant{
-			JID:         p.ToNonAD().String(),
+			JID:         getPreferredJID(ctx, client, p).ToNonAD().String(),
 			Action:      GroupParticipantActionDemote,
 			Affiliation: GroupAffiliationNone,
 		})
@@ -1165,26 +1238,32 @@ func newGroupEvent(evt *events.GroupInfo) (EventKind, *EventPayload) {
 // NewGroup returns a concrete [Group] for the primitive data given. This function will generally
 // populate fields with as much data as is available from the remote, and is therefore should not
 // be called when partial data is to be returned.
-func newGroup(client *whatsmeow.Client, info *types.GroupInfo) Group {
+func newGroup(ctx context.Context, client *whatsmeow.Client, info *types.GroupInfo) Group {
 	var participants []GroupParticipant
 	for i := range info.Participants {
-		p := newGroupParticipant(info.Participants[i])
+		p := newGroupParticipant(ctx, client, info.Participants[i])
 		if p.JID == "" {
 			continue
 		}
 		participants = append(participants, p)
 	}
-	return Group{
+
+	var topicJID = getPreferredJID(ctx, client, info.TopicSetBy, info.TopicSetByPN)
+	var group = Group{
 		JID:  info.JID.ToNonAD().String(),
-		Name: info.GroupName.Name,
+		Name: info.Name,
 		Subject: GroupSubject{
-			Subject:  info.Topic,
-			SetAt:    info.TopicSetAt.Unix(),
-			SetByJID: info.TopicSetBy.ToNonAD().String(),
+			Subject: info.Topic,
+			SetAt:   info.TopicSetAt.Unix(),
 		},
 		Nickname:     client.Store.PushName,
 		Participants: participants,
 	}
+	if c, err := client.Store.Contacts.GetContact(ctx, topicJID); err == nil {
+		group.Subject.SetBy = c.PushName
+	}
+
+	return group
 }
 
 // CallState represents the state of the call to synchronize with.
@@ -1229,3 +1308,25 @@ func newCallEvent(state CallState, meta types.BasicCallMeta) (EventKind, *EventP
 		Timestamp: meta.Timestamp.Unix(),
 	}}
 }
+
+// GetPreferredJID returns one of the [type.JID] values for the given senders, preferring the first
+// non-empty, non-hidden sender; if none are found, mappings from LID to JID are tried, or otherwise,
+// the first JID given is returned.
+func getPreferredJID(ctx context.Context, client *whatsmeow.Client, def types.JID, alt ...types.JID) types.JID {
+	var jids = append([]types.JID{def}, alt...)
+	for _, s := range jids {
+		if !s.IsEmpty() && s.Server != types.HiddenUserServer {
+			return s
+		}
+	}
+
+	for _, s := range jids {
+		if !s.IsEmpty() && s.Server == types.HiddenUserServer {
+			if p, _ := client.Store.LIDs.GetPNForLID(ctx, s); !p.IsEmpty() {
+				return p
+			}
+		}
+	}
+
+	return def
+}