status-go/protocol/messenger_contacts.go

1325 lines
35 KiB
Go

package protocol
import (
"context"
"crypto/ecdsa"
"errors"
"fmt"
"time"
"github.com/golang/protobuf/proto"
"go.uber.org/zap"
"github.com/ethereum/go-ethereum/log"
"github.com/status-im/status-go/deprecation"
"github.com/status-im/status-go/eth-node/crypto"
"github.com/status-im/status-go/eth-node/types"
"github.com/status-im/status-go/protocol/common"
"github.com/status-im/status-go/protocol/protobuf"
"github.com/status-im/status-go/protocol/requests"
"github.com/status-im/status-go/protocol/transport"
)
const outgoingMutualStateEventSentDefaultText = "You sent a contact request to @%s"
const outgoingMutualStateEventAcceptedDefaultText = "You accepted @%s's contact request"
const outgoingMutualStateEventRemovedDefaultText = "You removed @%s as a contact"
const incomingMutualStateEventSentDefaultText = "@%s sent you a contact request"
const incomingMutualStateEventAcceptedDefaultText = "@%s accepted your contact request"
const incomingMutualStateEventRemovedDefaultText = "@%s removed you as a contact"
type SelfContactChangeEvent struct {
DisplayNameChanged bool
PreferredNameChanged bool
BioChanged bool
SocialLinksChanged bool
ImagesChanged bool
}
func (m *Messenger) prepareMutualStateUpdateMessage(contactID string, updateType MutualStateUpdateType, clock uint64, timestamp uint64, outgoing bool) (*common.Message, error) {
var text string
var to string
var from string
var contentType protobuf.ChatMessage_ContentType
if outgoing {
to = contactID
from = m.myHexIdentity()
switch updateType {
case MutualStateUpdateTypeSent:
text = fmt.Sprintf(outgoingMutualStateEventSentDefaultText, contactID)
contentType = protobuf.ChatMessage_SYSTEM_MESSAGE_MUTUAL_EVENT_SENT
case MutualStateUpdateTypeAdded:
text = fmt.Sprintf(outgoingMutualStateEventAcceptedDefaultText, contactID)
contentType = protobuf.ChatMessage_SYSTEM_MESSAGE_MUTUAL_EVENT_ACCEPTED
case MutualStateUpdateTypeRemoved:
text = fmt.Sprintf(outgoingMutualStateEventRemovedDefaultText, contactID)
contentType = protobuf.ChatMessage_SYSTEM_MESSAGE_MUTUAL_EVENT_REMOVED
default:
return nil, fmt.Errorf("unhandled outgoing MutualStateUpdateType = %d", updateType)
}
} else {
to = m.myHexIdentity()
from = contactID
switch updateType {
case MutualStateUpdateTypeSent:
text = fmt.Sprintf(incomingMutualStateEventSentDefaultText, contactID)
contentType = protobuf.ChatMessage_SYSTEM_MESSAGE_MUTUAL_EVENT_SENT
case MutualStateUpdateTypeAdded:
text = fmt.Sprintf(incomingMutualStateEventAcceptedDefaultText, contactID)
contentType = protobuf.ChatMessage_SYSTEM_MESSAGE_MUTUAL_EVENT_ACCEPTED
case MutualStateUpdateTypeRemoved:
text = fmt.Sprintf(incomingMutualStateEventRemovedDefaultText, contactID)
contentType = protobuf.ChatMessage_SYSTEM_MESSAGE_MUTUAL_EVENT_REMOVED
default:
return nil, fmt.Errorf("unhandled incoming MutualStateUpdateType = %d", updateType)
}
}
message := &common.Message{
ChatMessage: &protobuf.ChatMessage{
ChatId: contactID,
Text: text,
MessageType: protobuf.MessageType_ONE_TO_ONE,
ContentType: contentType,
Clock: clock,
Timestamp: timestamp,
},
From: from,
WhisperTimestamp: timestamp,
LocalChatID: contactID,
Seen: true,
ID: types.EncodeHex(crypto.Keccak256([]byte(fmt.Sprintf("%s%s%d%d", from, to, updateType, clock)))),
}
return message, nil
}
func (m *Messenger) acceptContactRequest(ctx context.Context, requestID string, fromSyncing bool) (*MessengerResponse, error) {
contactRequest, err := m.persistence.MessageByID(requestID)
if err != nil {
m.logger.Error("could not find contact request message", zap.Error(err))
return nil, err
}
m.logger.Info("acceptContactRequest")
response, err := m.addContact(ctx, contactRequest.From, "", "", "", contactRequest.ID, "", fromSyncing, false, false)
if err != nil {
return nil, err
}
// Force activate chat
chat, ok := m.allChats.Load(contactRequest.From)
if !ok {
publicKey, err := common.HexToPubkey(contactRequest.From)
if err != nil {
return nil, err
}
chat = OneToOneFromPublicKey(publicKey, m.getTimesource())
}
chat.Active = true
if err := m.saveChat(chat); err != nil {
return nil, err
}
response.AddChat(chat)
return response, nil
}
func (m *Messenger) AcceptContactRequest(ctx context.Context, request *requests.AcceptContactRequest) (*MessengerResponse, error) {
err := request.Validate()
if err != nil {
return nil, err
}
response, err := m.acceptContactRequest(ctx, request.ID.String(), false)
if err != nil {
return nil, err
}
err = m.syncContactRequestDecision(ctx, request.ID.String(), true, m.dispatchMessage)
if err != nil {
return nil, err
}
return response, nil
}
func (m *Messenger) declineContactRequest(requestID string, fromSyncing bool) (*MessengerResponse, error) {
m.logger.Info("declineContactRequest")
contactRequest, err := m.persistence.MessageByID(requestID)
if err != nil {
return nil, err
}
contact, err := m.BuildContact(&requests.BuildContact{PublicKey: contactRequest.From})
if err != nil {
return nil, err
}
response := &MessengerResponse{}
if !fromSyncing {
_, clock, err := m.getOneToOneAndNextClock(contact)
if err != nil {
return nil, err
}
contact.DismissContactRequest(clock)
err = m.persistence.SaveContact(contact, nil)
if err != nil {
return nil, err
}
response.AddContact(contact)
}
contactRequest.ContactRequestState = common.ContactRequestStateDismissed
err = m.persistence.SetContactRequestState(contactRequest.ID, contactRequest.ContactRequestState)
if err != nil {
return nil, err
}
// update notification with the correct status
notification, err := m.persistence.GetActivityCenterNotificationByID(types.FromHex(contactRequest.ID))
if err != nil {
return nil, err
}
if notification != nil {
notification.Name = contact.PrimaryName()
notification.Message = contactRequest
notification.Read = true
notification.Dismissed = true
notification.UpdatedAt = m.GetCurrentTimeInMillis()
err = m.addActivityCenterNotification(response, notification, m.syncActivityCenterDismissedByIDs)
if err != nil {
m.logger.Error("failed to save notification", zap.Error(err))
return nil, err
}
}
response.AddMessage(contactRequest)
return response, nil
}
func (m *Messenger) DeclineContactRequest(ctx context.Context, request *requests.DeclineContactRequest) (*MessengerResponse, error) {
err := request.Validate()
if err != nil {
return nil, err
}
response, err := m.declineContactRequest(request.ID.String(), false)
if err != nil {
return nil, err
}
err = m.syncContactRequestDecision(ctx, request.ID.String(), false, m.dispatchMessage)
if err != nil {
return nil, err
}
return response, nil
}
func (m *Messenger) SendContactRequest(ctx context.Context, request *requests.SendContactRequest) (*MessengerResponse, error) {
err := request.Validate()
if err != nil {
return nil, err
}
chatID, err := request.HexID()
if err != nil {
return nil, err
}
return m.addContact(
ctx,
chatID,
"",
"",
"",
"",
request.Message,
false,
false,
true,
)
}
func (m *Messenger) updateAcceptedContactRequest(response *MessengerResponse, contactRequestID string, fromSyncing bool) (*MessengerResponse, error) {
m.logger.Debug("updateAcceptedContactRequest", zap.String("contactRequestID", contactRequestID))
contactRequest, err := m.persistence.MessageByID(contactRequestID)
if err != nil {
m.logger.Error("contact request not found", zap.String("contactRequestID", contactRequestID), zap.Error(err))
return nil, err
}
contactRequest.ContactRequestState = common.ContactRequestStateAccepted
err = m.persistence.SetContactRequestState(contactRequest.ID, contactRequest.ContactRequestState)
if err != nil {
return nil, err
}
contact, ok := m.allContacts.Load(contactRequest.From)
if !ok {
m.logger.Error("failed to update contact request: contact not found", zap.String("contact id", contactRequest.From))
return nil, errors.New("failed to update contact request: contact not found")
}
chat, ok := m.allChats.Load(contact.ID)
if !ok {
return nil, errors.New("no chat found for accepted contact request")
}
notification, err := m.persistence.GetActivityCenterNotificationByID(types.FromHex(contactRequest.ID))
if err != nil {
return nil, err
}
clock, _ := chat.NextClockAndTimestamp(m.transport)
contact.AcceptContactRequest(clock)
if !fromSyncing {
acceptContactRequest := &protobuf.AcceptContactRequest{
Id: contactRequest.ID,
Clock: clock,
}
encodedMessage, err := proto.Marshal(acceptContactRequest)
if err != nil {
return nil, err
}
_, err = m.dispatchMessage(context.Background(), common.RawMessage{
LocalChatID: contactRequest.From,
Payload: encodedMessage,
MessageType: protobuf.ApplicationMetadataMessage_ACCEPT_CONTACT_REQUEST,
ResendAutomatically: true,
})
if err != nil {
return nil, err
}
}
if response == nil {
response = &MessengerResponse{}
}
if notification != nil {
notification.Name = contact.PrimaryName()
notification.Message = contactRequest
notification.Read = true
notification.Accepted = true
notification.UpdatedAt = m.GetCurrentTimeInMillis()
err = m.addActivityCenterNotification(response, notification, nil)
if err != nil {
m.logger.Error("failed to save notification", zap.Error(err))
return nil, err
}
}
response.AddMessage(contactRequest)
response.AddContact(contact)
// Add mutual state update message for incoming contact request
clock, timestamp := chat.NextClockAndTimestamp(m.transport)
updateMessage, err := m.prepareMutualStateUpdateMessage(contact.ID, MutualStateUpdateTypeAdded, clock, timestamp, true)
if err != nil {
return nil, err
}
m.prepareMessage(updateMessage, m.httpServer)
err = m.persistence.SaveMessages([]*common.Message{updateMessage})
if err != nil {
return nil, err
}
response.AddMessage(updateMessage)
response.AddChat(chat)
return response, nil
}
func (m *Messenger) addContact(ctx context.Context, pubKey, ensName, nickname, displayName, contactRequestID string, contactRequestText string, fromSyncing bool, sendContactUpdate bool, createOutgoingContactRequestNotification bool) (*MessengerResponse, error) {
contact, err := m.BuildContact(&requests.BuildContact{PublicKey: pubKey})
if err != nil {
return nil, err
}
response := &MessengerResponse{}
chat, clock, err := m.getOneToOneAndNextClock(contact)
if err != nil {
return nil, err
}
if ensName != "" {
err := m.ensVerifier.ENSVerified(pubKey, ensName, clock)
if err != nil {
return nil, err
}
}
if err := m.addENSNameToContact(contact); err != nil {
return nil, err
}
if len(nickname) != 0 {
contact.LocalNickname = nickname
}
if len(displayName) != 0 {
contact.DisplayName = displayName
}
contact.LastUpdatedLocally = clock
contact.ContactRequestSent(clock)
if !fromSyncing {
// We sync the contact with the other devices
err := m.syncContact(context.Background(), contact, m.dispatchMessage)
if err != nil {
return nil, err
}
}
err = m.persistence.SaveContact(contact, nil)
if err != nil {
return nil, err
}
// TODO(samyoul) remove storing of an updated reference pointer?
m.allContacts.Store(contact.ID, contact)
// And we re-register for push notications
err = m.reregisterForPushNotifications()
if err != nil {
return nil, err
}
// Reset last published time for ChatIdentity so new contact can receive data
err = m.resetLastPublishedTimeForChatIdentity()
if err != nil {
return nil, err
}
// Profile chats are deprecated.
// Code below can be removed after some reasonable time.
//Create the corresponding chat
var profileChat *Chat
if !deprecation.ChatProfileDeprecated {
profileChat = m.buildProfileChat(contact.ID)
_, err = m.Join(profileChat)
if err != nil {
return nil, err
}
if err := m.saveChat(profileChat); err != nil {
return nil, err
}
}
publicKey, err := contact.PublicKey()
if err != nil {
return nil, err
}
// Fetch contact code
_, err = m.scheduleSyncFiltersForContact(publicKey)
if err != nil {
return nil, err
}
// Get ENS name of a current user
ensName, err = m.settings.ENSName()
if err != nil {
return nil, err
}
// Get display name of a current user
displayName, err = m.settings.DisplayName()
if err != nil {
return nil, err
}
if sendContactUpdate {
response, err = m.sendContactUpdate(context.Background(), pubKey, displayName, ensName, "", m.dispatchMessage)
if err != nil {
return nil, err
}
}
if len(contactRequestID) != 0 {
updatedResponse, err := m.updateAcceptedContactRequest(response, contactRequestID, false)
if err != nil {
return nil, err
}
err = response.Merge(updatedResponse)
if err != nil {
return nil, err
}
}
// Sends a standalone ChatIdentity message
err = m.handleStandaloneChatIdentity(chat)
if err != nil {
return nil, err
}
// Profile chats are deprecated.
// Code below can be removed after some reasonable time.
// Add chat
if !deprecation.ChatProfileDeprecated {
response.AddChat(profileChat)
_, err = m.transport.InitFilters([]transport.FiltersToInitialize{{ChatID: profileChat.ID}}, []*ecdsa.PublicKey{publicKey})
if err != nil {
return nil, err
}
}
// Publish contact code
err = m.publishContactCode()
if err != nil {
return nil, err
}
// Add mutual state update message for outgoing contact request
if len(contactRequestID) == 0 {
clock, timestamp := chat.NextClockAndTimestamp(m.transport)
updateMessage, err := m.prepareMutualStateUpdateMessage(contact.ID, MutualStateUpdateTypeSent, clock, timestamp, true)
if err != nil {
return nil, err
}
m.prepareMessage(updateMessage, m.httpServer)
err = m.persistence.SaveMessages([]*common.Message{updateMessage})
if err != nil {
return nil, err
}
response.AddMessage(updateMessage)
err = chat.UpdateFromMessage(updateMessage, m.getTimesource())
if err != nil {
return nil, err
}
response.AddChat(chat)
}
// Add outgoing contact request notification
if createOutgoingContactRequestNotification {
clock, timestamp := chat.NextClockAndTimestamp(m.transport)
contactRequest, err := m.generateContactRequest(clock, timestamp, contact, contactRequestText, true)
if err != nil {
return nil, err
}
// Send contact request as a plain chat message
messageResponse, err := m.sendChatMessage(ctx, contactRequest)
if err != nil {
return nil, err
}
err = response.Merge(messageResponse)
if err != nil {
return nil, err
}
notification := m.generateOutgoingContactRequestNotification(contact, contactRequest)
err = m.addActivityCenterNotification(response, notification, nil)
if err != nil {
return nil, err
}
}
// Add contact
response.AddContact(contact)
return response, nil
}
func (m *Messenger) generateContactRequest(clock uint64, timestamp uint64, contact *Contact, text string, outgoing bool) (*common.Message, error) {
if contact == nil {
return nil, errors.New("contact cannot be nil")
}
contactRequest := common.NewMessage()
contactRequest.ChatId = contact.ID
contactRequest.WhisperTimestamp = timestamp
contactRequest.Seen = true
contactRequest.Text = text
if outgoing {
contactRequest.From = m.myHexIdentity()
} else {
contactRequest.From = contact.ID
}
contactRequest.LocalChatID = contact.ID
contactRequest.ContentType = protobuf.ChatMessage_CONTACT_REQUEST
contactRequest.Clock = clock
if contact.mutual() {
contactRequest.ContactRequestState = common.ContactRequestStateAccepted
} else {
contactRequest.ContactRequestState = common.ContactRequestStatePending
}
err := contactRequest.PrepareContent(common.PubkeyToHex(&m.identity.PublicKey))
return contactRequest, err
}
func (m *Messenger) generateOutgoingContactRequestNotification(contact *Contact, contactRequest *common.Message) *ActivityCenterNotification {
return &ActivityCenterNotification{
ID: types.FromHex(contactRequest.ID),
Type: ActivityCenterNotificationTypeContactRequest,
Name: contact.PrimaryName(),
Author: m.myHexIdentity(),
Message: contactRequest,
Timestamp: m.getTimesource().GetCurrentTime(),
ChatID: contact.ID,
Read: contactRequest.ContactRequestState == common.ContactRequestStateAccepted ||
contactRequest.ContactRequestState == common.ContactRequestStateDismissed ||
contactRequest.ContactRequestState == common.ContactRequestStatePending,
Accepted: contactRequest.ContactRequestState == common.ContactRequestStateAccepted,
Dismissed: contactRequest.ContactRequestState == common.ContactRequestStateDismissed,
UpdatedAt: m.GetCurrentTimeInMillis(),
}
}
func (m *Messenger) AddContact(ctx context.Context, request *requests.AddContact) (*MessengerResponse, error) {
err := request.Validate()
if err != nil {
return nil, err
}
id, err := request.HexID()
if err != nil {
return nil, err
}
return m.addContact(
ctx,
id,
request.ENSName,
request.Nickname,
request.DisplayName,
"",
defaultContactRequestText(),
false,
true,
true,
)
}
func (m *Messenger) resetLastPublishedTimeForChatIdentity() error {
// Reset last published time for ChatIdentity so new contact can receive data
contactCodeTopic := transport.ContactCodeTopic(&m.identity.PublicKey)
m.logger.Debug("contact state changed ResetWhenChatIdentityLastPublished")
return m.persistence.ResetWhenChatIdentityLastPublished(contactCodeTopic)
}
func (m *Messenger) removeContact(ctx context.Context, response *MessengerResponse, pubKey string, sync bool) error {
contact, ok := m.allContacts.Load(pubKey)
if !ok {
return ErrContactNotFound
}
// System message for mutual state update
chat, clock, err := m.getOneToOneAndNextClock(contact)
if err != nil {
return err
}
timestamp := m.getTimesource().GetCurrentTime()
updateMessage, err := m.prepareMutualStateUpdateMessage(contact.ID, MutualStateUpdateTypeRemoved, clock, timestamp, true)
if err != nil {
return err
}
m.prepareMessage(updateMessage, m.httpServer)
err = m.persistence.SaveMessages([]*common.Message{updateMessage})
if err != nil {
return err
}
response.AddMessage(updateMessage)
err = chat.UpdateFromMessage(updateMessage, m.getTimesource())
if err != nil {
return err
}
response.AddChat(chat)
// Next we retract a contact request
contact.RetractContactRequest(clock)
contact.LastUpdatedLocally = m.getTimesource().GetCurrentTime()
err = m.persistence.SaveContact(contact, nil)
if err != nil {
return err
}
if sync {
err = m.syncContact(context.Background(), contact, m.dispatchMessage)
if err != nil {
return err
}
}
// TODO(samyoul) remove storing of an updated reference pointer?
m.allContacts.Store(contact.ID, contact)
// And we re-register for push notications
err = m.reregisterForPushNotifications()
if err != nil {
return err
}
// Profile chats are deprecated.
// Code below can be removed after some reasonable time.
//Create the corresponding profile chat
if !deprecation.ChatProfileDeprecated {
profileChatID := buildProfileChatID(contact.ID)
_, ok = m.allChats.Load(profileChatID)
if ok {
chatResponse, err := m.deactivateChat(profileChatID, 0, false, true)
if err != nil {
return err
}
err = response.Merge(chatResponse)
if err != nil {
return err
}
}
}
response.Contacts = []*Contact{contact}
return nil
}
func (m *Messenger) RemoveContact(ctx context.Context, pubKey string) (*MessengerResponse, error) {
response := new(MessengerResponse)
err := m.removeContact(ctx, response, pubKey, true)
if err != nil {
return nil, err
}
return response, nil
}
func (m *Messenger) updateContactImagesURL(contact *Contact) error {
if m.httpServer != nil {
for k, v := range contact.Images {
publicKey, err := contact.PublicKey()
if err != nil {
return err
}
v.LocalURL = m.httpServer.MakeContactImageURL(common.PubkeyToHex(publicKey), k)
contact.Images[k] = v
}
}
return nil
}
func (m *Messenger) Contacts() []*Contact {
var contacts []*Contact
m.allContacts.Range(func(contactID string, contact *Contact) (shouldContinue bool) {
contacts = append(contacts, contact)
return true
})
return contacts
}
func (m *Messenger) AddedContacts() []*Contact {
var contacts []*Contact
m.allContacts.Range(func(contactID string, contact *Contact) (shouldContinue bool) {
if contact.added() {
contacts = append(contacts, contact)
}
return true
})
return contacts
}
func (m *Messenger) MutualContacts() []*Contact {
var contacts []*Contact
m.allContacts.Range(func(contactID string, contact *Contact) (shouldContinue bool) {
if contact.mutual() {
contacts = append(contacts, contact)
}
return true
})
return contacts
}
func (m *Messenger) BlockedContacts() []*Contact {
var contacts []*Contact
m.allContacts.Range(func(contactID string, contact *Contact) (shouldContinue bool) {
if contact.Blocked {
contacts = append(contacts, contact)
}
return true
})
return contacts
}
// GetContactByID returns a Contact for given pubKey, if it's known.
// This function automatically checks if pubKey is self identity key and returns a Contact
// filled with self information.
// pubKey is assumed to include `0x` prefix
func (m *Messenger) GetContactByID(pubKey string) *Contact {
if pubKey == m.IdentityPublicKeyString() {
return m.selfContact
}
contact, _ := m.allContacts.Load(pubKey)
return contact
}
func (m *Messenger) GetSelfContact() *Contact {
return m.selfContact
}
func (m *Messenger) SetContactLocalNickname(request *requests.SetContactLocalNickname) (*MessengerResponse, error) {
if err := request.Validate(); err != nil {
return nil, err
}
pubKey := request.ID.String()
nickname := request.Nickname
contact, err := m.BuildContact(&requests.BuildContact{PublicKey: pubKey})
if err != nil {
return nil, err
}
if err := m.addENSNameToContact(contact); err != nil {
return nil, err
}
clock := m.getTimesource().GetCurrentTime()
contact.LocalNickname = nickname
contact.LastUpdatedLocally = clock
err = m.persistence.SaveContact(contact, nil)
if err != nil {
return nil, err
}
m.allContacts.Store(contact.ID, contact)
response := &MessengerResponse{}
response.Contacts = []*Contact{contact}
err = m.syncContact(context.Background(), contact, m.dispatchMessage)
if err != nil {
return nil, err
}
return response, nil
}
func (m *Messenger) blockContact(ctx context.Context, response *MessengerResponse, contactID string, isDesktopFunc bool, fromSyncing bool) error {
contact, err := m.BuildContact(&requests.BuildContact{PublicKey: contactID})
if err != nil {
return err
}
response.AddContact(contact)
_, clock, err := m.getOneToOneAndNextClock(contact)
if err != nil {
return err
}
contact.Block(clock)
contact.LastUpdatedLocally = m.getTimesource().GetCurrentTime()
chats, err := m.persistence.BlockContact(contact, isDesktopFunc)
if err != nil {
return err
}
response.AddChats(chats)
m.allContacts.Store(contact.ID, contact)
for _, chat := range chats {
m.allChats.Store(chat.ID, chat)
}
if !isDesktopFunc {
m.allChats.Delete(contact.ID)
m.allChats.Delete(buildProfileChatID(contact.ID))
}
if !fromSyncing {
err = m.sendRetractContactRequest(contact)
if err != nil {
return err
}
err = m.syncContact(context.Background(), contact, m.dispatchMessage)
if err != nil {
return err
}
// We remove anything that's related to this contact request
updatedAt := m.GetCurrentTimeInMillis()
notifications, err := m.persistence.DeleteChatContactRequestActivityCenterNotifications(contact.ID, updatedAt)
if err != nil {
return err
}
err = m.syncActivityCenterDeleted(ctx, notifications, updatedAt)
if err != nil {
m.logger.Error("BlockContact, error syncing activity center notifications as deleted", zap.Error(err))
return err
}
}
// re-register for push notifications
err = m.reregisterForPushNotifications()
if err != nil {
return err
}
return nil
}
func (m *Messenger) BlockContact(ctx context.Context, contactID string, fromSyncing bool) (*MessengerResponse, error) {
response := &MessengerResponse{}
err := m.blockContact(ctx, response, contactID, false, fromSyncing)
if err != nil {
return nil, err
}
response, err = m.DeclineAllPendingGroupInvitesFromUser(ctx, response, contactID)
if err != nil {
return nil, err
}
// AC notifications are synced separately
// NOTE: Should we still do the local part (persistence.dismiss...) and only skip the syncing?
// This would make the solution more reliable even in case AC notification sync is not recevied.
// This should be considered separately, I'm not sure if that's safe.
// https://github.com/status-im/status-go/issues/3720
if !fromSyncing {
updatedAt := m.GetCurrentTimeInMillis()
_, err = m.DismissAllActivityCenterNotificationsFromUser(ctx, contactID, updatedAt)
if err != nil {
return nil, err
}
}
return response, nil
}
// The same function as the one above.
// Should be removed with https://github.com/status-im/status-desktop/issues/8805
func (m *Messenger) BlockContactDesktop(ctx context.Context, contactID string) (*MessengerResponse, error) {
response := &MessengerResponse{}
err := m.blockContact(ctx, response, contactID, true, false)
if err != nil {
return nil, err
}
response, err = m.DeclineAllPendingGroupInvitesFromUser(ctx, response, contactID)
if err != nil {
return nil, err
}
notifications, err := m.DismissAllActivityCenterNotificationsFromUser(ctx, contactID, m.GetCurrentTimeInMillis())
if err != nil {
return nil, err
}
response.AddActivityCenterNotifications(notifications)
return response, nil
}
func (m *Messenger) UnblockContact(contactID string) (*MessengerResponse, error) {
response := &MessengerResponse{}
contact, ok := m.allContacts.Load(contactID)
if !ok || !contact.Blocked {
return response, nil
}
_, clock, err := m.getOneToOneAndNextClock(contact)
if err != nil {
return nil, err
}
contact.Unblock(clock)
contact.LastUpdatedLocally = m.getTimesource().GetCurrentTime()
err = m.persistence.SaveContact(contact, nil)
if err != nil {
return nil, err
}
m.allContacts.Store(contact.ID, contact)
response.AddContact(contact)
err = m.syncContact(context.Background(), contact, m.dispatchMessage)
if err != nil {
return nil, err
}
// re-register for push notifications
err = m.reregisterForPushNotifications()
if err != nil {
return nil, err
}
return response, nil
}
// Send contact updates to all contacts added by us
func (m *Messenger) SendContactUpdates(ctx context.Context, ensName, profileImage string) (err error) {
myID := contactIDFromPublicKey(&m.identity.PublicKey)
displayName, err := m.settings.DisplayName()
if err != nil {
return err
}
if _, err = m.sendContactUpdate(ctx, myID, displayName, ensName, profileImage, m.dispatchMessage); err != nil {
return err
}
// TODO: This should not be sending paired messages, as we do it above
m.allContacts.Range(func(contactID string, contact *Contact) (shouldContinue bool) {
if contact.added() {
if _, err = m.sendContactUpdate(ctx, contact.ID, displayName, ensName, profileImage, m.dispatchMessage); err != nil {
return false
}
}
return true
})
return err
}
// NOTE: this endpoint does not add the contact, the reason being is that currently
// that's left as a responsibility to the client, which will call both `SendContactUpdate`
// and `SaveContact` with the correct system tag.
// Ideally we have a single endpoint that does both, but probably best to bring `ENS` name
// on the messenger first.
// SendContactUpdate sends a contact update to a user and adds the user to contacts
func (m *Messenger) SendContactUpdate(ctx context.Context, chatID, ensName, profileImage string) (*MessengerResponse, error) {
displayName, err := m.settings.DisplayName()
if err != nil {
return nil, err
}
return m.sendContactUpdate(ctx, chatID, displayName, ensName, profileImage, m.dispatchMessage)
}
func (m *Messenger) sendContactUpdate(ctx context.Context, chatID, displayName, ensName, profileImage string, rawMessageHandler RawMessageHandler) (*MessengerResponse, error) {
var response MessengerResponse
contact, ok := m.allContacts.Load(chatID)
if !ok || !contact.added() {
return nil, nil
}
chat, clock, err := m.getOneToOneAndNextClock(contact)
if err != nil {
return nil, err
}
contactUpdate := &protobuf.ContactUpdate{
Clock: clock,
DisplayName: displayName,
EnsName: ensName,
ProfileImage: profileImage,
ContactRequestClock: contact.ContactRequestLocalClock,
ContactRequestPropagatedState: contact.ContactRequestPropagatedState(),
PublicKey: contact.ID,
}
encodedMessage, err := proto.Marshal(contactUpdate)
if err != nil {
return nil, err
}
rawMessage := common.RawMessage{
LocalChatID: chatID,
Payload: encodedMessage,
MessageType: protobuf.ApplicationMetadataMessage_CONTACT_UPDATE,
ResendAutomatically: true,
}
_, err = rawMessageHandler(ctx, rawMessage)
if err != nil {
return nil, err
}
response.Contacts = []*Contact{contact}
response.AddChat(chat)
chat.LastClockValue = clock
err = m.saveChat(chat)
if err != nil {
return nil, err
}
return &response, nil
}
func (m *Messenger) addENSNameToContact(contact *Contact) error {
// Check if there's already a verified record
ensRecord, err := m.ensVerifier.GetVerifiedRecord(contact.ID)
if err != nil {
return err
}
if ensRecord == nil {
return nil
}
contact.EnsName = ensRecord.Name
contact.ENSVerified = true
return nil
}
func (m *Messenger) RetractContactRequest(request *requests.RetractContactRequest) (*MessengerResponse, error) {
err := request.Validate()
if err != nil {
return nil, err
}
contact, ok := m.allContacts.Load(request.ID.String())
if !ok {
return nil, errors.New("contact not found")
}
response := &MessengerResponse{}
err = m.removeContact(context.Background(), response, contact.ID, true)
if err != nil {
return nil, err
}
err = m.sendRetractContactRequest(contact)
if err != nil {
return nil, err
}
return response, err
}
// Send message to remote account to remove our contact from their end.
func (m *Messenger) sendRetractContactRequest(contact *Contact) error {
_, clock, err := m.getOneToOneAndNextClock(contact)
if err != nil {
return err
}
retractContactRequest := &protobuf.RetractContactRequest{
Clock: clock,
}
encodedMessage, err := proto.Marshal(retractContactRequest)
if err != nil {
return err
}
_, err = m.dispatchMessage(context.Background(), common.RawMessage{
LocalChatID: contact.ID,
Payload: encodedMessage,
MessageType: protobuf.ApplicationMetadataMessage_RETRACT_CONTACT_REQUEST,
ResendAutomatically: true,
})
if err != nil {
return err
}
return err
}
func (m *Messenger) AcceptLatestContactRequestForContact(ctx context.Context, request *requests.AcceptLatestContactRequestForContact) (*MessengerResponse, error) {
if err := request.Validate(); err != nil {
return nil, err
}
contactRequestID, err := m.persistence.LatestPendingContactRequestIDForContact(request.ID.String())
if err != nil {
return nil, err
}
return m.AcceptContactRequest(ctx, &requests.AcceptContactRequest{ID: types.Hex2Bytes(contactRequestID)})
}
func (m *Messenger) DismissLatestContactRequestForContact(ctx context.Context, request *requests.DismissLatestContactRequestForContact) (*MessengerResponse, error) {
if err := request.Validate(); err != nil {
return nil, err
}
contactRequestID, err := m.persistence.LatestPendingContactRequestIDForContact(request.ID.String())
if err != nil {
return nil, err
}
return m.DeclineContactRequest(ctx, &requests.DeclineContactRequest{ID: types.Hex2Bytes(contactRequestID)})
}
func (m *Messenger) PendingContactRequests(cursor string, limit int) ([]*common.Message, string, error) {
return m.persistence.PendingContactRequests(cursor, limit)
}
func defaultContactRequestID(contactID string) string {
return "0x" + types.Bytes2Hex(append(types.Hex2Bytes(contactID), 0x20))
}
func defaultContactRequestText() string {
return "Please add me to your contacts"
}
func (m *Messenger) BuildContact(request *requests.BuildContact) (*Contact, error) {
contact, ok := m.allContacts.Load(request.PublicKey)
if !ok {
var err error
contact, err = buildContactFromPkString(request.PublicKey)
if err != nil {
return nil, err
}
if request.ENSName != "" {
contact.ENSVerified = true
contact.EnsName = request.ENSName
}
}
// Schedule sync filter to fetch information about the contact
publicKey, err := contact.PublicKey()
if err != nil {
return nil, err
}
_, err = m.scheduleSyncFiltersForContact(publicKey)
if err != nil {
return nil, err
}
return contact, nil
}
func (m *Messenger) scheduleSyncFiltersForContact(publicKey *ecdsa.PublicKey) (*transport.Filter, error) {
filter, err := m.transport.JoinPrivate(publicKey)
if err != nil {
return nil, err
}
_, err = m.scheduleSyncFilters([]*transport.Filter{filter})
if err != nil {
return filter, err
}
return filter, nil
}
func (m *Messenger) RequestContactInfoFromMailserver(pubkey string, waitForResponse bool) (*Contact, error) {
err := m.requestContactInfoFromMailserver(pubkey)
if err != nil {
return nil, err
}
if !waitForResponse {
return nil, nil
}
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer func() {
cancel()
m.forgetContactInfoRequest(pubkey)
}()
for {
select {
case <-time.After(200 * time.Millisecond):
contact, ok := m.allContacts.Load(pubkey)
if ok && contact != nil && contact.DisplayName != "" {
return contact, nil
}
case <-ctx.Done():
return nil, fmt.Errorf("failed to request contact info from mailserver: %w", ctx.Err())
}
}
}
func (m *Messenger) requestContactInfoFromMailserver(pubkey string) error {
m.requestedContactsLock.Lock()
defer m.requestedContactsLock.Unlock()
if _, ok := m.requestedContacts[pubkey]; ok {
return nil
}
m.logger.Debug("requesting contact info from mailserver", zap.String("publicKey", pubkey))
c, err := buildContactFromPkString(pubkey)
if err != nil {
return err
}
publicKey, err := c.PublicKey()
if err != nil {
return err
}
var filter *transport.Filter
filter, err = m.scheduleSyncFiltersForContact(publicKey)
if err != nil {
return err
}
m.requestedContacts[pubkey] = filter
return nil
}
func (m *Messenger) forgetContactInfoRequest(publicKey string) {
m.requestedContactsLock.Lock()
defer m.requestedContactsLock.Unlock()
filter, ok := m.requestedContacts[publicKey]
if !ok {
return
}
m.logger.Debug("forgetting contact info request", zap.String("publicKey", publicKey))
err := m.transport.RemoveFilters([]*transport.Filter{filter})
if err != nil {
m.logger.Warn("failed to remove filter", zap.Error(err))
}
delete(m.requestedContacts, publicKey)
}
func (m *Messenger) SubscribeToSelfContactChanges() chan *SelfContactChangeEvent {
s := make(chan *SelfContactChangeEvent, 10)
m.selfContactSubscriptions = append(m.selfContactSubscriptions, s)
return s
}
func (m *Messenger) publishSelfContactSubscriptions(event *SelfContactChangeEvent) {
for _, s := range m.selfContactSubscriptions {
select {
case s <- event:
default:
log.Warn("self contact subscription channel full, dropping message")
}
}
}