protocol/contact.go
package protocol
import (
"crypto/ecdsa"
"encoding/json"
"fmt"
accountJson "github.com/status-im/status-go/account/json"
"github.com/status-im/status-go/api/multiformat"
"github.com/status-im/status-go/eth-node/crypto"
"github.com/status-im/status-go/eth-node/types"
"github.com/status-im/status-go/images"
"github.com/status-im/status-go/multiaccounts"
"github.com/status-im/status-go/multiaccounts/accounts"
multiaccountscommon "github.com/status-im/status-go/multiaccounts/common"
"github.com/status-im/status-go/multiaccounts/settings"
"github.com/status-im/status-go/protocol/common"
"github.com/status-im/status-go/protocol/protobuf"
"github.com/status-im/status-go/protocol/verification"
)
type ContactRequestState int
const (
ContactRequestStateNone ContactRequestState = iota
ContactRequestStateMutual
ContactRequestStateSent
// Received is a confusing state, we should use
// sent for both, since they are now stored in different
// states
ContactRequestStateReceived
ContactRequestStateDismissed
)
type MutualStateUpdateType int
const (
MutualStateUpdateTypeSent MutualStateUpdateType = iota + 1
MutualStateUpdateTypeAdded
MutualStateUpdateTypeRemoved
)
// ContactDeviceInfo is a struct containing information about a particular device owned by a contact
type ContactDeviceInfo struct {
// The installation id of the device
InstallationID string `json:"id"`
// Timestamp represents the last time we received this info
Timestamp int64 `json:"timestamp"`
// FCMToken is to be used for push notifications
FCMToken string `json:"fcmToken"`
}
func (c *Contact) CanonicalImage(profilePicturesVisibility settings.ProfilePicturesVisibilityType) string {
if profilePicturesVisibility == settings.ProfilePicturesVisibilityNone || (profilePicturesVisibility == settings.ProfilePicturesVisibilityContactsOnly && !c.added()) {
return c.Identicon
}
if largeImage, ok := c.Images[images.LargeDimName]; ok {
imageBase64, err := largeImage.GetDataURI()
if err == nil {
return imageBase64
}
}
if thumbImage, ok := c.Images[images.SmallDimName]; ok {
imageBase64, err := thumbImage.GetDataURI()
if err == nil {
return imageBase64
}
}
return c.Identicon
}
type VerificationStatus int
const (
VerificationStatusUNVERIFIED VerificationStatus = iota
VerificationStatusVERIFYING
VerificationStatusVERIFIED
)
// Contact has information about a "Contact"
type Contact struct {
// ID of the contact. It's a hex-encoded public key (prefixed with 0x).
ID string `json:"id"`
// Ethereum address of the contact
Address string `json:"address,omitempty"`
// ENS name of contact
EnsName string `json:"name,omitempty"`
// EnsVerified whether we verified the name of the contact
ENSVerified bool `json:"ensVerified"`
// Generated username name of the contact
Alias string `json:"alias,omitempty"`
// Identicon generated from public key
Identicon string `json:"identicon"`
// LastUpdated is the last time we received an update from the contact
// updates should be discarded if last updated is less than the one stored
LastUpdated uint64 `json:"lastUpdated"`
// LastUpdatedLocally is the last time we updated the contact locally
LastUpdatedLocally uint64 `json:"lastUpdatedLocally"`
LocalNickname string `json:"localNickname,omitempty"`
// Display name of the contact
DisplayName string `json:"displayName"`
// Customization color of the contact
CustomizationColor multiaccountscommon.CustomizationColor `json:"customizationColor,omitempty"`
// Bio - description of the contact (tell us about yourself)
Bio string `json:"bio"`
Images map[string]images.IdentityImage `json:"images"`
Blocked bool `json:"blocked"`
// ContactRequestRemoteState is the state of the contact request
// on the contact's end
ContactRequestRemoteState ContactRequestState `json:"contactRequestRemoteState"`
// ContactRequestRemoteClock is the clock for incoming contact requests
ContactRequestRemoteClock uint64 `json:"contactRequestRemoteClock"`
// ContactRequestLocalState is the state of the contact request
// on our end
ContactRequestLocalState ContactRequestState `json:"contactRequestLocalState"`
// ContactRequestLocalClock is the clock for outgoing contact requests
ContactRequestLocalClock uint64 `json:"contactRequestLocalClock"`
IsSyncing bool
Removed bool
VerificationStatus VerificationStatus `json:"verificationStatus"`
TrustStatus verification.TrustStatus `json:"trustStatus"`
}
func (c Contact) IsVerified() bool {
return c.VerificationStatus == VerificationStatusVERIFIED
}
func (c Contact) IsVerifying() bool {
return c.VerificationStatus == VerificationStatusVERIFYING
}
func (c Contact) IsUnverified() bool {
return c.VerificationStatus == VerificationStatusUNVERIFIED
}
func (c Contact) IsUntrustworthy() bool {
return c.TrustStatus == verification.TrustStatusUNTRUSTWORTHY
}
func (c Contact) IsTrusted() bool {
return c.TrustStatus == verification.TrustStatusTRUSTED
}
func (c Contact) PublicKey() (*ecdsa.PublicKey, error) {
b, err := types.DecodeHex(c.ID)
if err != nil {
return nil, err
}
return crypto.UnmarshalPubkey(b)
}
func (c *Contact) Block(clock uint64) {
c.Blocked = true
c.DismissContactRequest(clock)
c.Removed = true
}
func (c *Contact) BlockDesktop() {
c.Blocked = true
}
func (c *Contact) Unblock(clock uint64) {
c.Blocked = false
// Reset the contact request flow
c.RetractContactRequest(clock)
}
func (c *Contact) added() bool {
return c.ContactRequestLocalState == ContactRequestStateSent
}
func (c *Contact) hasAddedUs() bool {
return c.ContactRequestRemoteState == ContactRequestStateReceived
}
func (c *Contact) mutual() bool {
return c.added() && c.hasAddedUs()
}
func (c *Contact) active() bool {
return c.mutual() && !c.Blocked
}
func (c *Contact) dismissed() bool {
return c.ContactRequestLocalState == ContactRequestStateDismissed
}
func (c *Contact) names() []string {
var names []string
if c.LocalNickname != "" {
names = append(names, c.LocalNickname)
}
if c.ENSVerified && len(c.EnsName) != 0 {
names = append(names, c.EnsName)
}
if c.DisplayName != "" {
names = append(names, c.DisplayName)
}
return append(names, c.Alias)
}
func (c *Contact) PrimaryName() string {
return c.names()[0]
}
func (c *Contact) SecondaryName() string {
// Only shown if the user has a nickname
if c.LocalNickname == "" {
return ""
}
names := c.names()
if len(names) > 1 {
return names[1]
}
return ""
}
type ContactRequestProcessingResponse struct {
processed bool
newContactRequestReceived bool
sendBackState bool
}
func (c *Contact) ContactRequestSent(clock uint64) ContactRequestProcessingResponse {
if clock <= c.ContactRequestLocalClock {
return ContactRequestProcessingResponse{}
}
c.ContactRequestLocalClock = clock
c.ContactRequestLocalState = ContactRequestStateSent
c.Removed = false
return ContactRequestProcessingResponse{processed: true}
}
func (c *Contact) AcceptContactRequest(clock uint64) ContactRequestProcessingResponse {
// We treat accept the same as sent, that's because accepting a contact
// request that does not exist is possible if the instruction is coming from
// a different device, we'd rather assume that a contact requested existed
// and didn't reach our device than being in an inconsistent state
return c.ContactRequestSent(clock)
}
func (c *Contact) RetractContactRequest(clock uint64) ContactRequestProcessingResponse {
if clock <= c.ContactRequestLocalClock {
return ContactRequestProcessingResponse{}
}
// This is a symmetric action, we set both local & remote clock
// since we want everything before this point discarded, regardless
// the side it was sent from
c.ContactRequestLocalClock = clock
c.ContactRequestLocalState = ContactRequestStateNone
c.ContactRequestRemoteState = ContactRequestStateNone
c.ContactRequestRemoteClock = clock
c.Removed = true
return ContactRequestProcessingResponse{processed: true}
}
func (c *Contact) DismissContactRequest(clock uint64) ContactRequestProcessingResponse {
if clock <= c.ContactRequestLocalClock {
return ContactRequestProcessingResponse{}
}
c.ContactRequestLocalClock = clock
c.ContactRequestLocalState = ContactRequestStateDismissed
return ContactRequestProcessingResponse{processed: true}
}
// Remote actions
func (c *Contact) contactRequestRetracted(clock uint64, fromSyncing bool, r ContactRequestProcessingResponse) ContactRequestProcessingResponse {
if clock <= c.ContactRequestRemoteClock {
return r
}
// This is a symmetric action, we set both local & remote clock
// since we want everything before this point discarded, regardless
// the side it was sent from. The only exception is when the contact
// request has been explicitly dismissed, in which case we don't
// change state
if c.ContactRequestLocalState != ContactRequestStateDismissed && !fromSyncing {
c.ContactRequestLocalClock = clock
c.ContactRequestLocalState = ContactRequestStateNone
}
c.ContactRequestRemoteClock = clock
c.ContactRequestRemoteState = ContactRequestStateNone
r.processed = true
return r
}
func (c *Contact) ContactRequestRetracted(clock uint64, fromSyncing bool) ContactRequestProcessingResponse {
return c.contactRequestRetracted(clock, fromSyncing, ContactRequestProcessingResponse{})
}
func (c *Contact) contactRequestReceived(clock uint64, r ContactRequestProcessingResponse) ContactRequestProcessingResponse {
if clock <= c.ContactRequestRemoteClock {
return r
}
r.processed = true
c.ContactRequestRemoteClock = clock
switch c.ContactRequestRemoteState {
case ContactRequestStateNone:
r.newContactRequestReceived = true
}
c.ContactRequestRemoteState = ContactRequestStateReceived
return r
}
func (c *Contact) ContactRequestReceived(clock uint64) ContactRequestProcessingResponse {
return c.contactRequestReceived(clock, ContactRequestProcessingResponse{})
}
func (c *Contact) ContactRequestAccepted(clock uint64) ContactRequestProcessingResponse {
if clock <= c.ContactRequestRemoteClock {
return ContactRequestProcessingResponse{}
}
// We treat received and accepted in the same way
// since the intention is clear on the other side
// and there's no difference
return c.ContactRequestReceived(clock)
}
func buildContactFromPkString(pkString string) (*Contact, error) {
publicKeyBytes, err := types.DecodeHex(pkString)
if err != nil {
return nil, err
}
publicKey, err := crypto.UnmarshalPubkey(publicKeyBytes)
if err != nil {
return nil, err
}
return buildContact(pkString, publicKey)
}
func BuildContactFromPublicKey(publicKey *ecdsa.PublicKey) (*Contact, error) {
id := common.PubkeyToHex(publicKey)
return buildContact(id, publicKey)
}
func getShortenedCompressedKey(publicKey string) string {
if len(publicKey) > 9 {
firstPart := publicKey[0:3]
ellipsis := "..."
publicKeySize := len(publicKey)
lastPart := publicKey[publicKeySize-6 : publicKeySize]
abbreviatedKey := fmt.Sprintf("%s%s%s", firstPart, ellipsis, lastPart)
return abbreviatedKey
}
return ""
}
func buildContact(publicKeyString string, publicKey *ecdsa.PublicKey) (*Contact, error) {
compressedKey, err := multiformat.SerializeLegacyKey(common.PubkeyToHex(publicKey))
if err != nil {
return nil, err
}
address := crypto.PubkeyToAddress(*publicKey)
contact := &Contact{
ID: publicKeyString,
Alias: getShortenedCompressedKey(compressedKey),
Address: types.EncodeHex(address[:]),
CustomizationColor: multiaccountscommon.CustomizationColorBlue,
}
return contact, nil
}
func buildSelfContact(identity *ecdsa.PrivateKey, settings *accounts.Database, multiAccounts *multiaccounts.Database, account *multiaccounts.Account) (*Contact, error) {
myPublicKeyString := types.EncodeHex(crypto.FromECDSAPub(&identity.PublicKey))
c, err := buildContact(myPublicKeyString, &identity.PublicKey)
if err != nil {
return nil, fmt.Errorf("failed to build contact: %w", err)
}
if settings != nil {
if s, err := settings.GetSettings(); err == nil {
c.DisplayName = s.DisplayName
c.Bio = s.Bio
if s.PreferredName != nil {
c.EnsName = *s.PreferredName
}
}
}
if multiAccounts != nil && account != nil {
if identityImages, err := multiAccounts.GetIdentityImages(account.KeyUID); err != nil {
imagesMap := make(map[string]images.IdentityImage)
for _, img := range identityImages {
imagesMap[img.Name] = *img
}
c.Images = imagesMap
}
if len(account.CustomizationColor) != 0 {
c.CustomizationColor = account.CustomizationColor
}
}
return c, nil
}
func contactIDFromPublicKey(key *ecdsa.PublicKey) string {
return types.EncodeHex(crypto.FromECDSAPub(key))
}
func contactIDFromPublicKeyString(key string) (string, error) {
pubKey, err := common.HexToPubkey(key)
if err != nil {
return "", err
}
return contactIDFromPublicKey(pubKey), nil
}
func (c *Contact) ProcessSyncContactRequestState(remoteState ContactRequestState, remoteClock uint64, localState ContactRequestState, localClock uint64) {
// We process the two separately, first local state
switch localState {
case ContactRequestStateDismissed:
c.DismissContactRequest(localClock)
case ContactRequestStateNone:
c.RetractContactRequest(localClock)
case ContactRequestStateSent:
c.ContactRequestSent(localClock)
}
// and later remote state
switch remoteState {
case ContactRequestStateReceived:
c.ContactRequestReceived(remoteClock)
case ContactRequestStateNone:
c.ContactRequestRetracted(remoteClock, true)
}
}
func (c *Contact) MarshalJSON() ([]byte, error) {
type Alias Contact
type ContactType struct {
*Alias
Added bool `json:"added"`
ContactRequestState ContactRequestState `json:"contactRequestState"`
HasAddedUs bool `json:"hasAddedUs"`
Mutual bool `json:"mutual"`
Active bool `json:"active"`
PrimaryName string `json:"primaryName"`
SecondaryName string `json:"secondaryName,omitempty"`
}
item := ContactType{
Alias: (*Alias)(c),
}
item.Added = c.added()
item.HasAddedUs = c.hasAddedUs()
item.Mutual = c.mutual()
item.Active = c.active()
item.PrimaryName = c.PrimaryName()
item.SecondaryName = c.SecondaryName()
if c.mutual() {
item.ContactRequestState = ContactRequestStateMutual
} else if c.dismissed() {
item.ContactRequestState = ContactRequestStateDismissed
} else if c.added() {
item.ContactRequestState = ContactRequestStateSent
} else if c.hasAddedUs() {
item.ContactRequestState = ContactRequestStateReceived
}
ext, err := accountJson.ExtendStructWithPubKeyData(item.ID, item)
if err != nil {
return nil, err
}
return json.Marshal(ext)
}
// ContactRequestPropagatedStateReceived handles the propagation of state from
// the other end.
func (c *Contact) ContactRequestPropagatedStateReceived(state *protobuf.ContactRequestPropagatedState) ContactRequestProcessingResponse {
// It's inverted, as their local states is our remote state
expectedLocalState := ContactRequestState(state.RemoteState)
expectedLocalClock := state.RemoteClock
remoteState := ContactRequestState(state.LocalState)
remoteClock := state.LocalClock
response := ContactRequestProcessingResponse{}
// If we notice that the state is not consistent, and their clock is
// outdated, we send back the state so they can catch up.
if expectedLocalClock < c.ContactRequestLocalClock && expectedLocalState != c.ContactRequestLocalState {
response.processed = true
response.sendBackState = true
}
// If they expect our state to be more up-to-date, we only
// trust it if the state is set to None, in this case we can trust
// it, since a retraction can be initiated by both parties
if expectedLocalClock > c.ContactRequestLocalClock && c.ContactRequestLocalState != ContactRequestStateDismissed && expectedLocalState == ContactRequestStateNone {
response.processed = true
c.ContactRequestLocalClock = expectedLocalClock
c.ContactRequestLocalState = ContactRequestStateNone
// We set the remote state, as this was an implicit retraction
// potentially, for example this could happen if they
// sent a retraction earier, but we never received it,
// or one of our paired devices has retracted the contact request
// but we never synced with them.
c.ContactRequestRemoteState = ContactRequestStateNone
}
// We always trust this
if remoteClock > c.ContactRequestRemoteClock {
if remoteState == ContactRequestStateSent {
response = c.contactRequestReceived(remoteClock, response)
} else if remoteState == ContactRequestStateNone {
response = c.contactRequestRetracted(remoteClock, false, response)
}
}
return response
}
func (c *Contact) ContactRequestPropagatedState() *protobuf.ContactRequestPropagatedState {
return &protobuf.ContactRequestPropagatedState{
LocalClock: c.ContactRequestLocalClock,
LocalState: uint64(c.ContactRequestLocalState),
RemoteClock: c.ContactRequestRemoteClock,
RemoteState: uint64(c.ContactRequestRemoteState),
}
}