2019-11-21 16:19:22 +00:00
|
|
|
package protocol
|
2019-10-14 14:10:48 +00:00
|
|
|
|
|
|
|
import (
|
2020-01-10 18:59:01 +00:00
|
|
|
"crypto/ecdsa"
|
|
|
|
"encoding/hex"
|
2020-02-10 11:22:37 +00:00
|
|
|
"fmt"
|
2020-11-30 11:19:18 +00:00
|
|
|
|
2019-10-14 14:10:48 +00:00
|
|
|
"github.com/pkg/errors"
|
|
|
|
|
2020-01-10 18:59:01 +00:00
|
|
|
"github.com/status-im/status-go/eth-node/crypto"
|
2020-08-07 13:49:37 +00:00
|
|
|
"github.com/status-im/status-go/eth-node/types"
|
2020-11-25 00:34:32 +00:00
|
|
|
"github.com/status-im/status-go/images"
|
2020-07-22 07:41:40 +00:00
|
|
|
"github.com/status-im/status-go/protocol/common"
|
2020-01-10 18:59:01 +00:00
|
|
|
"github.com/status-im/status-go/protocol/encryption/multidevice"
|
2019-12-02 15:34:05 +00:00
|
|
|
"github.com/status-im/status-go/protocol/protobuf"
|
2019-11-21 16:19:22 +00:00
|
|
|
v1protocol "github.com/status-im/status-go/protocol/v1"
|
2020-11-25 13:57:34 +00:00
|
|
|
|
|
|
|
"go.uber.org/zap"
|
2019-10-14 14:10:48 +00:00
|
|
|
)
|
|
|
|
|
2020-02-21 14:48:53 +00:00
|
|
|
const (
|
|
|
|
transactionRequestDeclinedMessage = "Transaction request declined"
|
|
|
|
requestAddressForTransactionAcceptedMessage = "Request address for transaction accepted"
|
|
|
|
requestAddressForTransactionDeclinedMessage = "Request address for transaction declined"
|
|
|
|
)
|
|
|
|
|
2020-01-10 18:59:01 +00:00
|
|
|
type MessageHandler struct {
|
|
|
|
identity *ecdsa.PrivateKey
|
|
|
|
persistence *sqlitePersistence
|
|
|
|
logger *zap.Logger
|
|
|
|
}
|
|
|
|
|
|
|
|
func newMessageHandler(identity *ecdsa.PrivateKey, logger *zap.Logger, persistence *sqlitePersistence) *MessageHandler {
|
|
|
|
return &MessageHandler{
|
|
|
|
identity: identity,
|
|
|
|
persistence: persistence,
|
|
|
|
logger: logger}
|
|
|
|
}
|
|
|
|
|
2019-10-14 14:10:48 +00:00
|
|
|
// HandleMembershipUpdate updates a Chat instance according to the membership updates.
|
|
|
|
// It retrieves chat, if exists, and merges membership updates from the message.
|
|
|
|
// Finally, the Chat is updated with the new group events.
|
2020-01-10 18:59:01 +00:00
|
|
|
func (m *MessageHandler) HandleMembershipUpdate(messageState *ReceivedMessageState, chat *Chat, rawMembershipUpdate protobuf.MembershipUpdateMessage, translations map[protobuf.MembershipUpdateEvent_EventType]string) error {
|
|
|
|
var group *v1protocol.Group
|
|
|
|
var err error
|
|
|
|
|
2020-01-20 16:44:32 +00:00
|
|
|
logger := m.logger.With(zap.String("site", "HandleMembershipUpdate"))
|
|
|
|
|
2020-01-10 18:59:01 +00:00
|
|
|
message, err := v1protocol.MembershipUpdateMessageFromProtobuf(&rawMembershipUpdate)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2020-01-20 16:44:32 +00:00
|
|
|
if err := ValidateMembershipUpdateMessage(message, messageState.Timesource.GetCurrentTime()); err != nil {
|
|
|
|
logger.Warn("failed to validate message", zap.Error(err))
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-08-07 13:49:37 +00:00
|
|
|
//if chat.InvitationAdmin exists means we are waiting for invitation request approvement, and in that case
|
|
|
|
//we need to create a new chat instance like we don't have a chat and just use a regular invitation flow
|
|
|
|
if chat == nil || len(chat.InvitationAdmin) > 0 {
|
2020-01-10 18:59:01 +00:00
|
|
|
if len(message.Events) == 0 {
|
|
|
|
return errors.New("can't create new group chat without events")
|
2019-10-14 14:10:48 +00:00
|
|
|
}
|
2020-08-07 13:49:37 +00:00
|
|
|
|
|
|
|
//approve invitations
|
|
|
|
if chat != nil && len(chat.InvitationAdmin) > 0 {
|
|
|
|
|
|
|
|
groupChatInvitation := &GroupChatInvitation{
|
|
|
|
GroupChatInvitation: protobuf.GroupChatInvitation{
|
|
|
|
ChatId: message.ChatID,
|
|
|
|
},
|
|
|
|
From: types.EncodeHex(crypto.FromECDSAPub(&m.identity.PublicKey)),
|
|
|
|
}
|
|
|
|
|
|
|
|
groupChatInvitation, err = m.persistence.InvitationByID(groupChatInvitation.ID())
|
2020-10-08 10:46:03 +00:00
|
|
|
if err != nil && err != common.ErrRecordNotFound {
|
2020-08-07 13:49:37 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
if groupChatInvitation != nil {
|
|
|
|
groupChatInvitation.State = protobuf.GroupChatInvitation_APPROVED
|
|
|
|
|
|
|
|
err := m.persistence.SaveInvitation(groupChatInvitation)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
messageState.GroupChatInvitations[groupChatInvitation.ID()] = groupChatInvitation
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-10 18:59:01 +00:00
|
|
|
group, err = v1protocol.NewGroupWithEvents(message.ChatID, message.Events)
|
2019-10-14 14:10:48 +00:00
|
|
|
if err != nil {
|
2020-01-10 18:59:01 +00:00
|
|
|
return err
|
2019-10-14 14:10:48 +00:00
|
|
|
}
|
2019-12-02 15:34:05 +00:00
|
|
|
|
|
|
|
// A new chat must contain us
|
2020-01-15 07:25:09 +00:00
|
|
|
if !group.IsMember(contactIDFromPublicKey(&m.identity.PublicKey)) {
|
2020-01-10 18:59:01 +00:00
|
|
|
return errors.New("can't create a new group chat without us being a member")
|
2019-10-14 14:10:48 +00:00
|
|
|
}
|
2020-02-07 11:30:26 +00:00
|
|
|
newChat := CreateGroupChat(messageState.Timesource)
|
2020-01-10 18:59:01 +00:00
|
|
|
chat = &newChat
|
|
|
|
} else {
|
|
|
|
existingGroup, err := newProtocolGroupFromChat(chat)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "failed to create a Group from Chat")
|
|
|
|
}
|
|
|
|
updateGroup, err := v1protocol.NewGroupWithEvents(message.ChatID, message.Events)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "invalid membership update")
|
|
|
|
}
|
|
|
|
merged := v1protocol.MergeMembershipUpdateEvents(existingGroup.Events(), updateGroup.Events())
|
2020-03-09 06:19:23 +00:00
|
|
|
group, err = v1protocol.NewGroupWithEvents(chat.ID, merged)
|
2020-01-10 18:59:01 +00:00
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "failed to create a group with new membership updates")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-22 12:58:28 +00:00
|
|
|
chat.updateChatFromGroupMembershipChanges(contactIDFromPublicKey(&m.identity.PublicKey), group)
|
|
|
|
|
2020-01-10 18:59:01 +00:00
|
|
|
systemMessages := buildSystemMessages(message.Events, translations)
|
|
|
|
|
|
|
|
for _, message := range systemMessages {
|
|
|
|
messageID := message.ID
|
|
|
|
exists, err := m.messageExists(messageID, messageState.ExistingMessagesMap)
|
|
|
|
if err != nil {
|
|
|
|
m.logger.Warn("failed to check message exists", zap.Error(err))
|
|
|
|
}
|
|
|
|
if exists {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
messageState.Response.Messages = append(messageState.Response.Messages, message)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Store in chats map as it might be a new one
|
|
|
|
messageState.AllChats[chat.ID] = chat
|
|
|
|
// Set in the map
|
|
|
|
messageState.ModifiedChats[chat.ID] = true
|
|
|
|
|
2020-07-26 21:37:04 +00:00
|
|
|
if message.Message != nil {
|
|
|
|
messageState.CurrentMessageState.Message = *message.Message
|
2020-01-10 18:59:01 +00:00
|
|
|
return m.HandleChatMessage(messageState)
|
2020-07-28 14:34:49 +00:00
|
|
|
} else if message.EmojiReaction != nil {
|
|
|
|
return m.HandleEmojiReaction(messageState, *message.EmojiReaction)
|
2019-10-14 14:10:48 +00:00
|
|
|
}
|
2020-01-10 18:59:01 +00:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-09-01 13:27:01 +00:00
|
|
|
func (m *MessageHandler) handleCommandMessage(state *ReceivedMessageState, message *common.Message) error {
|
2020-01-10 18:59:01 +00:00
|
|
|
message.ID = state.CurrentMessageState.MessageID
|
|
|
|
message.From = state.CurrentMessageState.Contact.ID
|
|
|
|
message.Alias = state.CurrentMessageState.Contact.Alias
|
|
|
|
message.SigPubKey = state.CurrentMessageState.PublicKey
|
|
|
|
message.Identicon = state.CurrentMessageState.Contact.Identicon
|
|
|
|
message.WhisperTimestamp = state.CurrentMessageState.WhisperTimestamp
|
|
|
|
|
2020-02-10 11:22:37 +00:00
|
|
|
if err := message.PrepareContent(); err != nil {
|
|
|
|
return fmt.Errorf("failed to prepare content: %v", err)
|
|
|
|
}
|
2020-07-25 14:16:00 +00:00
|
|
|
chat, err := m.matchChatEntity(message, state.AllChats, state.Timesource)
|
2019-10-14 14:10:48 +00:00
|
|
|
if err != nil {
|
2020-01-10 18:59:01 +00:00
|
|
|
return err
|
2019-10-14 14:10:48 +00:00
|
|
|
}
|
2020-01-10 18:59:01 +00:00
|
|
|
|
|
|
|
// If deleted-at is greater, ignore message
|
|
|
|
if chat.DeletedAtClockValue >= message.Clock {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the LocalChatID for the message
|
|
|
|
message.LocalChatID = chat.ID
|
|
|
|
|
|
|
|
if c, ok := state.AllChats[chat.ID]; ok {
|
|
|
|
chat = c
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the LocalChatID for the message
|
|
|
|
message.LocalChatID = chat.ID
|
|
|
|
|
|
|
|
// Increase unviewed count
|
2020-07-06 08:54:22 +00:00
|
|
|
if !common.IsPubKeyEqual(message.SigPubKey, &m.identity.PublicKey) {
|
2020-01-10 18:59:01 +00:00
|
|
|
chat.UnviewedMessagesCount++
|
|
|
|
message.OutgoingStatus = ""
|
|
|
|
} else {
|
|
|
|
// Our own message, mark as sent
|
2020-09-01 13:27:01 +00:00
|
|
|
message.OutgoingStatus = common.OutgoingStatusSent
|
2020-01-10 18:59:01 +00:00
|
|
|
}
|
|
|
|
|
2020-01-20 16:44:32 +00:00
|
|
|
err = chat.UpdateFromMessage(message, state.Timesource)
|
2019-12-02 15:34:05 +00:00
|
|
|
if err != nil {
|
2020-01-10 18:59:01 +00:00
|
|
|
return err
|
2019-10-14 14:10:48 +00:00
|
|
|
}
|
2020-01-10 18:59:01 +00:00
|
|
|
|
|
|
|
// Set chat active
|
|
|
|
chat.Active = true
|
|
|
|
// Set in the modified maps chat
|
|
|
|
state.ModifiedChats[chat.ID] = true
|
|
|
|
state.AllChats[chat.ID] = chat
|
|
|
|
|
|
|
|
// Add to response
|
|
|
|
if message != nil {
|
|
|
|
state.Response.Messages = append(state.Response.Messages, message)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *MessageHandler) HandleSyncInstallationContact(state *ReceivedMessageState, message protobuf.SyncInstallationContact) error {
|
|
|
|
chat, ok := state.AllChats[state.CurrentMessageState.Contact.ID]
|
|
|
|
if !ok {
|
2020-01-20 16:44:32 +00:00
|
|
|
chat = OneToOneFromPublicKey(state.CurrentMessageState.PublicKey, state.Timesource)
|
2020-01-10 18:59:01 +00:00
|
|
|
// We don't want to show the chat to the user
|
|
|
|
chat.Active = false
|
|
|
|
}
|
|
|
|
|
|
|
|
contact, ok := state.AllContacts[message.Id]
|
|
|
|
if !ok {
|
|
|
|
publicKeyBytes, err := hex.DecodeString(message.Id[2:])
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
publicKey, err := crypto.UnmarshalPubkey(publicKeyBytes)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
contact, err = buildContact(publicKey)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if contact.LastUpdated < message.Clock {
|
|
|
|
if !contact.IsAdded() {
|
|
|
|
contact.SystemTags = append(contact.SystemTags, contactAdded)
|
|
|
|
}
|
|
|
|
if contact.Name != message.EnsName {
|
|
|
|
contact.Name = message.EnsName
|
|
|
|
contact.ENSVerified = false
|
|
|
|
}
|
|
|
|
contact.LastUpdated = message.Clock
|
2020-08-20 14:06:38 +00:00
|
|
|
contact.LocalNickname = message.LocalNickname
|
|
|
|
|
2020-01-10 18:59:01 +00:00
|
|
|
state.ModifiedContacts[contact.ID] = true
|
|
|
|
state.AllContacts[contact.ID] = contact
|
|
|
|
}
|
|
|
|
|
|
|
|
state.AllChats[chat.ID] = chat
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-09-07 08:25:57 +00:00
|
|
|
func (m *MessageHandler) HandleSyncInstallationPublicChat(state *ReceivedMessageState, message protobuf.SyncInstallationPublicChat) bool {
|
2020-01-15 07:25:09 +00:00
|
|
|
chatID := message.Id
|
|
|
|
_, ok := state.AllChats[chatID]
|
|
|
|
if ok {
|
2020-09-07 08:25:57 +00:00
|
|
|
return false
|
2020-01-15 07:25:09 +00:00
|
|
|
}
|
|
|
|
|
2020-01-20 16:44:32 +00:00
|
|
|
chat := CreatePublicChat(chatID, state.Timesource)
|
2020-01-15 07:25:09 +00:00
|
|
|
|
|
|
|
state.AllChats[chat.ID] = &chat
|
|
|
|
state.ModifiedChats[chat.ID] = true
|
|
|
|
|
2020-09-07 08:25:57 +00:00
|
|
|
return true
|
2020-01-15 07:25:09 +00:00
|
|
|
}
|
|
|
|
|
2020-01-10 18:59:01 +00:00
|
|
|
func (m *MessageHandler) HandleContactUpdate(state *ReceivedMessageState, message protobuf.ContactUpdate) error {
|
|
|
|
logger := m.logger.With(zap.String("site", "HandleContactUpdate"))
|
|
|
|
contact := state.CurrentMessageState.Contact
|
|
|
|
chat, ok := state.AllChats[contact.ID]
|
|
|
|
if !ok {
|
2020-01-20 16:44:32 +00:00
|
|
|
chat = OneToOneFromPublicKey(state.CurrentMessageState.PublicKey, state.Timesource)
|
2020-01-10 18:59:01 +00:00
|
|
|
// We don't want to show the chat to the user
|
|
|
|
chat.Active = false
|
|
|
|
}
|
|
|
|
|
|
|
|
logger.Info("Handling contact update")
|
|
|
|
|
|
|
|
if contact.LastUpdated < message.Clock {
|
|
|
|
logger.Info("Updating contact")
|
2020-01-15 07:25:09 +00:00
|
|
|
if !contact.HasBeenAdded() && contact.ID != contactIDFromPublicKey(&m.identity.PublicKey) {
|
2020-01-10 18:59:01 +00:00
|
|
|
contact.SystemTags = append(contact.SystemTags, contactRequestReceived)
|
|
|
|
}
|
|
|
|
if contact.Name != message.EnsName {
|
|
|
|
contact.Name = message.EnsName
|
|
|
|
contact.ENSVerified = false
|
|
|
|
}
|
|
|
|
contact.LastUpdated = message.Clock
|
|
|
|
state.ModifiedContacts[contact.ID] = true
|
|
|
|
state.AllContacts[contact.ID] = contact
|
|
|
|
}
|
|
|
|
|
|
|
|
if chat.LastClockValue < message.Clock {
|
|
|
|
chat.LastClockValue = message.Clock
|
|
|
|
}
|
|
|
|
|
|
|
|
state.ModifiedChats[chat.ID] = true
|
|
|
|
state.AllChats[chat.ID] = chat
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *MessageHandler) HandlePairInstallation(state *ReceivedMessageState, message protobuf.PairInstallation) error {
|
|
|
|
logger := m.logger.With(zap.String("site", "HandlePairInstallation"))
|
2020-01-20 16:44:32 +00:00
|
|
|
if err := ValidateReceivedPairInstallation(&message, state.CurrentMessageState.WhisperTimestamp); err != nil {
|
2020-01-10 18:59:01 +00:00
|
|
|
logger.Warn("failed to validate message", zap.Error(err))
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
installation, ok := state.AllInstallations[message.InstallationId]
|
|
|
|
if !ok {
|
|
|
|
return errors.New("installation not found")
|
|
|
|
}
|
|
|
|
|
|
|
|
metadata := &multidevice.InstallationMetadata{
|
|
|
|
Name: message.Name,
|
|
|
|
DeviceType: message.DeviceType,
|
|
|
|
}
|
|
|
|
|
|
|
|
installation.InstallationMetadata = metadata
|
|
|
|
state.AllInstallations[message.InstallationId] = installation
|
|
|
|
state.ModifiedInstallations[message.InstallationId] = true
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *MessageHandler) HandleChatMessage(state *ReceivedMessageState) error {
|
|
|
|
logger := m.logger.With(zap.String("site", "handleChatMessage"))
|
2020-01-20 16:44:32 +00:00
|
|
|
if err := ValidateReceivedChatMessage(&state.CurrentMessageState.Message, state.CurrentMessageState.WhisperTimestamp); err != nil {
|
2020-01-10 18:59:01 +00:00
|
|
|
logger.Warn("failed to validate message", zap.Error(err))
|
|
|
|
return err
|
|
|
|
}
|
2020-09-01 13:27:01 +00:00
|
|
|
receivedMessage := &common.Message{
|
2020-01-10 18:59:01 +00:00
|
|
|
ID: state.CurrentMessageState.MessageID,
|
|
|
|
ChatMessage: state.CurrentMessageState.Message,
|
|
|
|
From: state.CurrentMessageState.Contact.ID,
|
|
|
|
Alias: state.CurrentMessageState.Contact.Alias,
|
|
|
|
SigPubKey: state.CurrentMessageState.PublicKey,
|
|
|
|
Identicon: state.CurrentMessageState.Contact.Identicon,
|
|
|
|
WhisperTimestamp: state.CurrentMessageState.WhisperTimestamp,
|
|
|
|
}
|
|
|
|
|
2020-02-10 11:22:37 +00:00
|
|
|
err := receivedMessage.PrepareContent()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to prepare message content: %v", err)
|
|
|
|
}
|
2020-07-25 14:16:00 +00:00
|
|
|
chat, err := m.matchChatEntity(receivedMessage, state.AllChats, state.Timesource)
|
2020-01-10 18:59:01 +00:00
|
|
|
if err != nil {
|
2020-07-25 14:16:00 +00:00
|
|
|
return err // matchChatEntity returns a descriptive error message
|
2020-01-10 18:59:01 +00:00
|
|
|
}
|
|
|
|
|
2020-10-20 15:10:28 +00:00
|
|
|
// If profile updates check if author is the same as chat profile public key
|
|
|
|
if chat.ProfileUpdates() && receivedMessage.From != chat.Profile {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-01-10 18:59:01 +00:00
|
|
|
// If deleted-at is greater, ignore message
|
2020-11-06 13:47:02 +00:00
|
|
|
if chat.DeletedAtClockValue >= receivedMessage.Clock {
|
2020-01-10 18:59:01 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the LocalChatID for the message
|
|
|
|
receivedMessage.LocalChatID = chat.ID
|
|
|
|
|
|
|
|
if c, ok := state.AllChats[chat.ID]; ok {
|
|
|
|
chat = c
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the LocalChatID for the message
|
|
|
|
receivedMessage.LocalChatID = chat.ID
|
|
|
|
|
|
|
|
// Increase unviewed count
|
2020-07-06 08:54:22 +00:00
|
|
|
if !common.IsPubKeyEqual(receivedMessage.SigPubKey, &m.identity.PublicKey) {
|
2020-01-10 18:59:01 +00:00
|
|
|
chat.UnviewedMessagesCount++
|
|
|
|
} else {
|
|
|
|
// Our own message, mark as sent
|
2020-09-01 13:27:01 +00:00
|
|
|
receivedMessage.OutgoingStatus = common.OutgoingStatusSent
|
2020-01-10 18:59:01 +00:00
|
|
|
}
|
|
|
|
|
2020-01-20 16:44:32 +00:00
|
|
|
err = chat.UpdateFromMessage(receivedMessage, state.Timesource)
|
2019-12-02 15:34:05 +00:00
|
|
|
if err != nil {
|
2020-01-10 18:59:01 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set chat active
|
|
|
|
chat.Active = true
|
|
|
|
// Set in the modified maps chat
|
|
|
|
state.ModifiedChats[chat.ID] = true
|
|
|
|
state.AllChats[chat.ID] = chat
|
|
|
|
|
2020-02-05 10:09:33 +00:00
|
|
|
contact := state.CurrentMessageState.Contact
|
|
|
|
if hasENSNameChanged(contact, receivedMessage.EnsName, receivedMessage.Clock) {
|
|
|
|
contact.ResetENSVerification(receivedMessage.Clock, receivedMessage.EnsName)
|
|
|
|
state.ModifiedContacts[contact.ID] = true
|
|
|
|
state.AllContacts[contact.ID] = contact
|
|
|
|
}
|
|
|
|
|
2020-01-10 18:59:01 +00:00
|
|
|
// Add to response
|
2020-07-25 14:16:00 +00:00
|
|
|
state.Response.Messages = append(state.Response.Messages, receivedMessage)
|
2020-01-10 18:59:01 +00:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *MessageHandler) HandleRequestAddressForTransaction(messageState *ReceivedMessageState, command protobuf.RequestAddressForTransaction) error {
|
2020-01-20 16:44:32 +00:00
|
|
|
err := ValidateReceivedRequestAddressForTransaction(&command, messageState.CurrentMessageState.WhisperTimestamp)
|
2020-01-10 18:59:01 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2020-09-01 13:27:01 +00:00
|
|
|
message := &common.Message{
|
2020-01-10 18:59:01 +00:00
|
|
|
ChatMessage: protobuf.ChatMessage{
|
|
|
|
Clock: command.Clock,
|
|
|
|
Timestamp: messageState.CurrentMessageState.WhisperTimestamp,
|
|
|
|
Text: "Request address for transaction",
|
2020-01-15 07:25:09 +00:00
|
|
|
ChatId: contactIDFromPublicKey(&m.identity.PublicKey),
|
2020-07-25 11:46:43 +00:00
|
|
|
MessageType: protobuf.MessageType_ONE_TO_ONE,
|
2020-01-10 18:59:01 +00:00
|
|
|
ContentType: protobuf.ChatMessage_TRANSACTION_COMMAND,
|
|
|
|
},
|
2020-09-01 13:27:01 +00:00
|
|
|
CommandParameters: &common.CommandParameters{
|
2020-01-10 18:59:01 +00:00
|
|
|
ID: messageState.CurrentMessageState.MessageID,
|
|
|
|
Value: command.Value,
|
|
|
|
Contract: command.Contract,
|
2020-09-01 13:27:01 +00:00
|
|
|
CommandState: common.CommandStateRequestAddressForTransaction,
|
2020-01-10 18:59:01 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
return m.handleCommandMessage(messageState, message)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *MessageHandler) HandleRequestTransaction(messageState *ReceivedMessageState, command protobuf.RequestTransaction) error {
|
2020-01-20 16:44:32 +00:00
|
|
|
err := ValidateReceivedRequestTransaction(&command, messageState.CurrentMessageState.WhisperTimestamp)
|
2020-01-10 18:59:01 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2020-09-01 13:27:01 +00:00
|
|
|
message := &common.Message{
|
2020-01-10 18:59:01 +00:00
|
|
|
ChatMessage: protobuf.ChatMessage{
|
|
|
|
Clock: command.Clock,
|
|
|
|
Timestamp: messageState.CurrentMessageState.WhisperTimestamp,
|
|
|
|
Text: "Request transaction",
|
2020-01-15 07:25:09 +00:00
|
|
|
ChatId: contactIDFromPublicKey(&m.identity.PublicKey),
|
2020-07-25 11:46:43 +00:00
|
|
|
MessageType: protobuf.MessageType_ONE_TO_ONE,
|
2020-01-10 18:59:01 +00:00
|
|
|
ContentType: protobuf.ChatMessage_TRANSACTION_COMMAND,
|
|
|
|
},
|
2020-09-01 13:27:01 +00:00
|
|
|
CommandParameters: &common.CommandParameters{
|
2020-01-10 18:59:01 +00:00
|
|
|
ID: messageState.CurrentMessageState.MessageID,
|
|
|
|
Value: command.Value,
|
|
|
|
Contract: command.Contract,
|
2020-09-01 13:27:01 +00:00
|
|
|
CommandState: common.CommandStateRequestTransaction,
|
2020-01-10 18:59:01 +00:00
|
|
|
Address: command.Address,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
return m.handleCommandMessage(messageState, message)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *MessageHandler) HandleAcceptRequestAddressForTransaction(messageState *ReceivedMessageState, command protobuf.AcceptRequestAddressForTransaction) error {
|
2020-01-20 16:44:32 +00:00
|
|
|
err := ValidateReceivedAcceptRequestAddressForTransaction(&command, messageState.CurrentMessageState.WhisperTimestamp)
|
2020-01-10 18:59:01 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
initialMessage, err := m.persistence.MessageByID(command.Id)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if initialMessage == nil {
|
|
|
|
return errors.New("message not found")
|
|
|
|
}
|
|
|
|
|
|
|
|
if initialMessage.LocalChatID != messageState.CurrentMessageState.Contact.ID {
|
|
|
|
return errors.New("From must match")
|
|
|
|
}
|
|
|
|
|
|
|
|
if initialMessage.OutgoingStatus == "" {
|
|
|
|
return errors.New("Initial message must originate from us")
|
|
|
|
}
|
|
|
|
|
2020-09-01 13:27:01 +00:00
|
|
|
if initialMessage.CommandParameters.CommandState != common.CommandStateRequestAddressForTransaction {
|
2020-01-10 18:59:01 +00:00
|
|
|
return errors.New("Wrong state for command")
|
|
|
|
}
|
|
|
|
|
|
|
|
initialMessage.Clock = command.Clock
|
|
|
|
initialMessage.Timestamp = messageState.CurrentMessageState.WhisperTimestamp
|
2020-02-21 14:48:53 +00:00
|
|
|
initialMessage.Text = requestAddressForTransactionAcceptedMessage
|
2020-01-10 18:59:01 +00:00
|
|
|
initialMessage.CommandParameters.Address = command.Address
|
2020-04-06 12:08:53 +00:00
|
|
|
initialMessage.Seen = false
|
2020-09-01 13:27:01 +00:00
|
|
|
initialMessage.CommandParameters.CommandState = common.CommandStateRequestAddressForTransactionAccepted
|
2020-01-10 18:59:01 +00:00
|
|
|
|
|
|
|
// Hide previous message
|
2020-01-17 12:39:09 +00:00
|
|
|
previousMessage, err := m.persistence.MessageByCommandID(messageState.CurrentMessageState.Contact.ID, command.Id)
|
2020-10-08 10:46:03 +00:00
|
|
|
if err != nil && err != common.ErrRecordNotFound {
|
2020-01-10 18:59:01 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if previousMessage != nil {
|
|
|
|
err = m.persistence.HideMessage(previousMessage.ID)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
initialMessage.Replace = previousMessage.ID
|
|
|
|
}
|
|
|
|
|
|
|
|
return m.handleCommandMessage(messageState, initialMessage)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *MessageHandler) HandleSendTransaction(messageState *ReceivedMessageState, command protobuf.SendTransaction) error {
|
2020-01-20 16:44:32 +00:00
|
|
|
err := ValidateReceivedSendTransaction(&command, messageState.CurrentMessageState.WhisperTimestamp)
|
2020-01-10 18:59:01 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
transactionToValidate := &TransactionToValidate{
|
|
|
|
MessageID: messageState.CurrentMessageState.MessageID,
|
|
|
|
CommandID: command.Id,
|
|
|
|
TransactionHash: command.TransactionHash,
|
|
|
|
FirstSeen: messageState.CurrentMessageState.WhisperTimestamp,
|
|
|
|
Signature: command.Signature,
|
|
|
|
Validate: true,
|
|
|
|
From: messageState.CurrentMessageState.PublicKey,
|
|
|
|
RetryCount: 0,
|
|
|
|
}
|
|
|
|
m.logger.Info("Saving transction to validate", zap.Any("transaction", transactionToValidate))
|
|
|
|
|
|
|
|
return m.persistence.SaveTransactionToValidate(transactionToValidate)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *MessageHandler) HandleDeclineRequestAddressForTransaction(messageState *ReceivedMessageState, command protobuf.DeclineRequestAddressForTransaction) error {
|
2020-01-20 16:44:32 +00:00
|
|
|
err := ValidateReceivedDeclineRequestAddressForTransaction(&command, messageState.CurrentMessageState.WhisperTimestamp)
|
2020-01-10 18:59:01 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
oldMessage, err := m.persistence.MessageByID(command.Id)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if oldMessage == nil {
|
|
|
|
return errors.New("message not found")
|
|
|
|
}
|
|
|
|
|
|
|
|
if oldMessage.LocalChatID != messageState.CurrentMessageState.Contact.ID {
|
|
|
|
return errors.New("From must match")
|
|
|
|
}
|
|
|
|
|
|
|
|
if oldMessage.OutgoingStatus == "" {
|
|
|
|
return errors.New("Initial message must originate from us")
|
|
|
|
}
|
|
|
|
|
2020-09-01 13:27:01 +00:00
|
|
|
if oldMessage.CommandParameters.CommandState != common.CommandStateRequestAddressForTransaction {
|
2020-01-10 18:59:01 +00:00
|
|
|
return errors.New("Wrong state for command")
|
|
|
|
}
|
|
|
|
|
|
|
|
oldMessage.Clock = command.Clock
|
|
|
|
oldMessage.Timestamp = messageState.CurrentMessageState.WhisperTimestamp
|
2020-02-21 14:48:53 +00:00
|
|
|
oldMessage.Text = requestAddressForTransactionDeclinedMessage
|
2020-04-06 12:08:53 +00:00
|
|
|
oldMessage.Seen = false
|
2020-09-01 13:27:01 +00:00
|
|
|
oldMessage.CommandParameters.CommandState = common.CommandStateRequestAddressForTransactionDeclined
|
2020-01-10 18:59:01 +00:00
|
|
|
|
|
|
|
// Hide previous message
|
|
|
|
err = m.persistence.HideMessage(command.Id)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
oldMessage.Replace = command.Id
|
|
|
|
|
|
|
|
return m.handleCommandMessage(messageState, oldMessage)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *MessageHandler) HandleDeclineRequestTransaction(messageState *ReceivedMessageState, command protobuf.DeclineRequestTransaction) error {
|
2020-01-20 16:44:32 +00:00
|
|
|
err := ValidateReceivedDeclineRequestTransaction(&command, messageState.CurrentMessageState.WhisperTimestamp)
|
2020-01-10 18:59:01 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
oldMessage, err := m.persistence.MessageByID(command.Id)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if oldMessage == nil {
|
|
|
|
return errors.New("message not found")
|
|
|
|
}
|
|
|
|
|
|
|
|
if oldMessage.LocalChatID != messageState.CurrentMessageState.Contact.ID {
|
|
|
|
return errors.New("From must match")
|
|
|
|
}
|
|
|
|
|
|
|
|
if oldMessage.OutgoingStatus == "" {
|
|
|
|
return errors.New("Initial message must originate from us")
|
|
|
|
}
|
|
|
|
|
2020-09-01 13:27:01 +00:00
|
|
|
if oldMessage.CommandParameters.CommandState != common.CommandStateRequestTransaction {
|
2020-01-10 18:59:01 +00:00
|
|
|
return errors.New("Wrong state for command")
|
|
|
|
}
|
|
|
|
|
|
|
|
oldMessage.Clock = command.Clock
|
|
|
|
oldMessage.Timestamp = messageState.CurrentMessageState.WhisperTimestamp
|
2020-02-21 14:48:53 +00:00
|
|
|
oldMessage.Text = transactionRequestDeclinedMessage
|
2020-04-06 12:08:53 +00:00
|
|
|
oldMessage.Seen = false
|
2020-09-01 13:27:01 +00:00
|
|
|
oldMessage.CommandParameters.CommandState = common.CommandStateRequestTransactionDeclined
|
2020-01-10 18:59:01 +00:00
|
|
|
|
|
|
|
// Hide previous message
|
|
|
|
err = m.persistence.HideMessage(command.Id)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
oldMessage.Replace = command.Id
|
|
|
|
|
|
|
|
return m.handleCommandMessage(messageState, oldMessage)
|
|
|
|
}
|
|
|
|
|
2020-07-27 10:13:22 +00:00
|
|
|
func (m *MessageHandler) matchChatEntity(chatEntity common.ChatEntity, chats map[string]*Chat, timesource TimeSource) (*Chat, error) {
|
2020-07-25 14:16:00 +00:00
|
|
|
if chatEntity.GetSigPubKey() == nil {
|
2020-01-10 18:59:01 +00:00
|
|
|
m.logger.Error("public key can't be empty")
|
2020-07-25 14:16:00 +00:00
|
|
|
return nil, errors.New("received a chatEntity with empty public key")
|
2020-01-10 18:59:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch {
|
2020-07-25 14:16:00 +00:00
|
|
|
case chatEntity.GetMessageType() == protobuf.MessageType_PUBLIC_GROUP:
|
2020-01-10 18:59:01 +00:00
|
|
|
// For public messages, all outgoing and incoming messages have the same chatID
|
|
|
|
// equal to a public chat name.
|
2020-07-25 14:16:00 +00:00
|
|
|
chatID := chatEntity.GetChatId()
|
2020-01-10 18:59:01 +00:00
|
|
|
chat := chats[chatID]
|
|
|
|
if chat == nil {
|
2020-07-25 14:16:00 +00:00
|
|
|
return nil, errors.New("received a public chatEntity from non-existing chat")
|
2020-01-10 18:59:01 +00:00
|
|
|
}
|
|
|
|
return chat, nil
|
2020-07-27 10:13:22 +00:00
|
|
|
case chatEntity.GetMessageType() == protobuf.MessageType_ONE_TO_ONE && common.IsPubKeyEqual(chatEntity.GetSigPubKey(), &m.identity.PublicKey):
|
2020-02-10 11:22:37 +00:00
|
|
|
// It's a private message coming from us so we rely on Message.ChatID
|
2020-01-10 18:59:01 +00:00
|
|
|
// If chat does not exist, it should be created to support multidevice synchronization.
|
2020-07-25 14:16:00 +00:00
|
|
|
chatID := chatEntity.GetChatId()
|
2020-01-10 18:59:01 +00:00
|
|
|
chat := chats[chatID]
|
|
|
|
if chat == nil {
|
|
|
|
if len(chatID) != PubKeyStringLength {
|
|
|
|
return nil, errors.New("invalid pubkey length")
|
|
|
|
}
|
|
|
|
bytePubKey, err := hex.DecodeString(chatID[2:])
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "failed to decode hex chatID")
|
|
|
|
}
|
|
|
|
|
|
|
|
pubKey, err := crypto.UnmarshalPubkey(bytePubKey)
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "failed to decode pubkey")
|
|
|
|
}
|
|
|
|
|
2020-01-20 16:44:32 +00:00
|
|
|
newChat := CreateOneToOneChat(chatID[:8], pubKey, timesource)
|
2020-01-10 18:59:01 +00:00
|
|
|
chat = &newChat
|
|
|
|
}
|
|
|
|
return chat, nil
|
2020-07-25 14:16:00 +00:00
|
|
|
case chatEntity.GetMessageType() == protobuf.MessageType_ONE_TO_ONE:
|
|
|
|
// It's an incoming private chatEntity. ChatID is calculated from the signature.
|
2020-01-10 18:59:01 +00:00
|
|
|
// If a chat does not exist, a new one is created and saved.
|
2020-07-25 14:16:00 +00:00
|
|
|
chatID := contactIDFromPublicKey(chatEntity.GetSigPubKey())
|
2020-01-10 18:59:01 +00:00
|
|
|
chat := chats[chatID]
|
|
|
|
if chat == nil {
|
|
|
|
// TODO: this should be a three-word name used in the mobile client
|
2020-07-25 14:16:00 +00:00
|
|
|
newChat := CreateOneToOneChat(chatID[:8], chatEntity.GetSigPubKey(), timesource)
|
2020-01-10 18:59:01 +00:00
|
|
|
chat = &newChat
|
|
|
|
}
|
|
|
|
return chat, nil
|
2020-07-25 14:16:00 +00:00
|
|
|
case chatEntity.GetMessageType() == protobuf.MessageType_PRIVATE_GROUP:
|
|
|
|
// In the case of a group chatEntity, ChatID is the same for all messages belonging to a group.
|
2020-01-10 18:59:01 +00:00
|
|
|
// It needs to be verified if the signature public key belongs to the chat.
|
2020-07-25 14:16:00 +00:00
|
|
|
chatID := chatEntity.GetChatId()
|
2020-01-10 18:59:01 +00:00
|
|
|
chat := chats[chatID]
|
|
|
|
if chat == nil {
|
2020-07-25 14:16:00 +00:00
|
|
|
return nil, errors.New("received group chat chatEntity for non-existing chat")
|
2020-01-10 18:59:01 +00:00
|
|
|
}
|
|
|
|
|
2020-07-25 14:16:00 +00:00
|
|
|
theirKeyHex := contactIDFromPublicKey(chatEntity.GetSigPubKey())
|
2020-01-15 07:25:09 +00:00
|
|
|
myKeyHex := contactIDFromPublicKey(&m.identity.PublicKey)
|
2020-01-10 18:59:01 +00:00
|
|
|
var theyJoined bool
|
|
|
|
var iJoined bool
|
|
|
|
for _, member := range chat.Members {
|
|
|
|
if member.ID == theirKeyHex && member.Joined {
|
|
|
|
theyJoined = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for _, member := range chat.Members {
|
|
|
|
if member.ID == myKeyHex && member.Joined {
|
|
|
|
iJoined = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if theyJoined && iJoined {
|
|
|
|
return chat, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil, errors.New("did not find a matching group chat")
|
|
|
|
default:
|
|
|
|
return nil, errors.New("can not match a chat because there is no valid case")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *MessageHandler) messageExists(messageID string, existingMessagesMap map[string]bool) (bool, error) {
|
|
|
|
if _, ok := existingMessagesMap[messageID]; ok {
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
existingMessagesMap[messageID] = true
|
|
|
|
|
|
|
|
// Check against the database, this is probably a bit slow for
|
|
|
|
// each message, but for now might do, we'll make it faster later
|
|
|
|
existingMessage, err := m.persistence.MessageByID(messageID)
|
2020-10-08 10:46:03 +00:00
|
|
|
if err != nil && err != common.ErrRecordNotFound {
|
2020-01-10 18:59:01 +00:00
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
if existingMessage != nil {
|
|
|
|
return true, nil
|
2019-10-14 14:10:48 +00:00
|
|
|
}
|
2020-01-10 18:59:01 +00:00
|
|
|
return false, nil
|
2019-10-14 14:10:48 +00:00
|
|
|
}
|
2020-07-24 13:47:58 +00:00
|
|
|
|
2020-07-25 14:16:00 +00:00
|
|
|
func (m *MessageHandler) HandleEmojiReaction(state *ReceivedMessageState, pbEmojiR protobuf.EmojiReaction) error {
|
2020-07-24 13:47:58 +00:00
|
|
|
logger := m.logger.With(zap.String("site", "HandleEmojiReaction"))
|
2020-07-28 07:53:32 +00:00
|
|
|
if err := ValidateReceivedEmojiReaction(&pbEmojiR, state.Timesource.GetCurrentTime()); err != nil {
|
|
|
|
logger.Error("invalid emoji reaction", zap.Error(err))
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-07-27 12:27:48 +00:00
|
|
|
from := state.CurrentMessageState.Contact.ID
|
|
|
|
|
2020-07-28 07:53:32 +00:00
|
|
|
emojiReaction := &EmojiReaction{
|
|
|
|
EmojiReaction: pbEmojiR,
|
|
|
|
From: from,
|
|
|
|
SigPubKey: state.CurrentMessageState.PublicKey,
|
|
|
|
}
|
|
|
|
|
|
|
|
existingEmoji, err := m.persistence.EmojiReactionByID(emojiReaction.ID())
|
2020-10-08 10:46:03 +00:00
|
|
|
if err != common.ErrRecordNotFound && err != nil {
|
2020-07-27 12:27:48 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if existingEmoji != nil && existingEmoji.Clock >= pbEmojiR.Clock {
|
|
|
|
// this is not a valid emoji, ignoring
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-07-25 14:16:00 +00:00
|
|
|
chat, err := m.matchChatEntity(emojiReaction, state.AllChats, state.Timesource)
|
|
|
|
if err != nil {
|
|
|
|
return err // matchChatEntity returns a descriptive error message
|
2020-07-24 13:47:58 +00:00
|
|
|
}
|
|
|
|
|
2020-07-28 07:53:32 +00:00
|
|
|
// Set local chat id
|
|
|
|
emojiReaction.LocalChatID = chat.ID
|
|
|
|
|
|
|
|
logger.Debug("Handling emoji reaction")
|
2020-07-24 13:47:58 +00:00
|
|
|
|
2020-07-25 14:16:00 +00:00
|
|
|
if chat.LastClockValue < pbEmojiR.Clock {
|
|
|
|
chat.LastClockValue = pbEmojiR.Clock
|
2020-07-24 13:47:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
state.ModifiedChats[chat.ID] = true
|
|
|
|
state.AllChats[chat.ID] = chat
|
|
|
|
|
2020-07-27 12:27:48 +00:00
|
|
|
// save emoji reaction
|
|
|
|
err = m.persistence.SaveEmojiReaction(emojiReaction)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
state.EmojiReactions[emojiReaction.ID()] = emojiReaction
|
2020-07-27 10:13:22 +00:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2020-08-07 13:49:37 +00:00
|
|
|
|
|
|
|
func (m *MessageHandler) HandleGroupChatInvitation(state *ReceivedMessageState, pbGHInvitations protobuf.GroupChatInvitation) error {
|
|
|
|
logger := m.logger.With(zap.String("site", "HandleGroupChatInvitation"))
|
|
|
|
if err := ValidateReceivedGroupChatInvitation(&pbGHInvitations); err != nil {
|
|
|
|
logger.Error("invalid group chat invitation", zap.Error(err))
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
groupChatInvitation := &GroupChatInvitation{
|
|
|
|
GroupChatInvitation: pbGHInvitations,
|
|
|
|
SigPubKey: state.CurrentMessageState.PublicKey,
|
|
|
|
}
|
|
|
|
|
|
|
|
//From is the PK of author of invitation request
|
|
|
|
if groupChatInvitation.State == protobuf.GroupChatInvitation_REJECTED {
|
|
|
|
//rejected so From is the current user who received this rejection
|
|
|
|
groupChatInvitation.From = types.EncodeHex(crypto.FromECDSAPub(&m.identity.PublicKey))
|
|
|
|
} else {
|
|
|
|
//invitation request, so From is the author of message
|
|
|
|
groupChatInvitation.From = state.CurrentMessageState.Contact.ID
|
|
|
|
}
|
|
|
|
|
|
|
|
existingInvitation, err := m.persistence.InvitationByID(groupChatInvitation.ID())
|
2020-10-08 10:46:03 +00:00
|
|
|
if err != common.ErrRecordNotFound && err != nil {
|
2020-08-07 13:49:37 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if existingInvitation != nil && existingInvitation.Clock >= pbGHInvitations.Clock {
|
|
|
|
// this is not a valid invitation, ignoring
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// save invitation
|
|
|
|
err = m.persistence.SaveInvitation(groupChatInvitation)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
state.GroupChatInvitations[groupChatInvitation.ID()] = groupChatInvitation
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2020-11-18 12:41:36 +00:00
|
|
|
|
|
|
|
// HandleChatIdentity handles an incoming protobuf.ChatIdentity
|
|
|
|
// extracts contact information stored in the protobuf and adds it to the user's contact for update.
|
|
|
|
func (m *MessageHandler) HandleChatIdentity(state *ReceivedMessageState, ci protobuf.ChatIdentity) error {
|
|
|
|
logger := m.logger.With(zap.String("site", "HandleChatIdentity"))
|
|
|
|
contact := state.CurrentMessageState.Contact
|
|
|
|
|
|
|
|
logger.Info("Handling contact update")
|
2020-12-15 15:28:05 +00:00
|
|
|
newImages, err := m.persistence.SaveContactChatIdentity(contact.ID, &ci)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if newImages {
|
|
|
|
for imageType, image := range ci.Images {
|
|
|
|
if contact.Images == nil {
|
|
|
|
contact.Images = make(map[string]images.IdentityImage)
|
2020-11-30 11:03:44 +00:00
|
|
|
}
|
2020-12-15 15:28:05 +00:00
|
|
|
contact.Images[imageType] = images.IdentityImage{Name: imageType, Payload: image.Payload}
|
2020-12-02 09:31:48 +00:00
|
|
|
|
2020-11-18 12:41:36 +00:00
|
|
|
}
|
|
|
|
state.ModifiedContacts[contact.ID] = true
|
|
|
|
state.AllContacts[contact.ID] = contact
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|