status-im/status-go

package pairing

import (
    "context"
    "crypto/ecdsa"
    "fmt"
    "strings"

    ethcrypto "github.com/ethereum/go-ethereum/crypto"

    "github.com/status-im/status-go/api"
    "github.com/status-im/status-go/multiaccounts/accounts"
    "github.com/status-im/status-go/multiaccounts/settings"
    "github.com/status-im/status-go/protocol/encryption/multidevice"
    "github.com/status-im/status-go/protocol/protobuf"
    "github.com/status-im/status-go/protocol/requests"
    "github.com/status-im/status-go/signal"
)

type SyncRawMessageHandler struct {
    backend *api.GethStatusBackend
}

func NewSyncRawMessageHandler(backend *api.GethStatusBackend) *SyncRawMessageHandler {
    return &SyncRawMessageHandler{backend: backend}
}

func (s *SyncRawMessageHandler) CollectInstallationData(rawMessageCollector *RawMessageCollector, deviceType string) error {
    // TODO Could this function be part of the installation data exchange flow?
    //  https://github.com/status-im/status-go/issues/3304
    messenger := s.backend.Messenger()
    if messenger == nil {
        return fmt.Errorf("messenger is nil when CollectInstallationData")
    }
    err := messenger.SetInstallationDeviceType(deviceType)
    if err != nil {
        return err
    }
    _, err = messenger.SendPairInstallation(context.TODO(), rawMessageCollector.dispatchMessage)
    return err
}

func (s *SyncRawMessageHandler) PrepareRawMessage(keyUID, deviceType string) (rm []*protobuf.RawMessage, kp *accounts.Keypair, syncSettings *settings.Settings, err error) {
    syncSettings = new(settings.Settings)
    messenger := s.backend.Messenger()
    if messenger == nil {
        return nil, nil, nil, fmt.Errorf("messenger is nil when PrepareRawMessage")
    }

    currentAccount, err := s.backend.GetActiveAccount()
    if err != nil {
        return
    }
    if keyUID != currentAccount.KeyUID {
        return nil, nil, nil, fmt.Errorf("keyUID not equal")
    }

    messenger.SetLocalPairing(true)
    defer func() {
        messenger.SetLocalPairing(false)
    }()
    rawMessageCollector := new(RawMessageCollector)
    err = messenger.SyncDevices(context.TODO(), currentAccount.Name, currentAccount.Identicon, rawMessageCollector.dispatchMessage)
    if err != nil {
        return
    }

    err = s.CollectInstallationData(rawMessageCollector, deviceType)
    if err != nil {
        return
    }

    rsm := rawMessageCollector.convertToSyncRawMessage()
    rm = rsm.RawMessages

    accountService := s.backend.StatusNode().AccountService()

    kp, err = accountService.GetKeypairByKeyUID(keyUID)
    if err != nil {
        return
    }
    *syncSettings, err = accountService.GetSettings()
    if err != nil {
        return
    }

    return
}

func (s *SyncRawMessageHandler) HandleRawMessage(
    accountPayload *AccountPayload,
    createAccountRequest *requests.CreateAccount,
    deviceType string,
    rmp *RawMessagesPayload) (err error) {

    activeAccount, _ := s.backend.GetActiveAccount()
    if activeAccount == nil { // not login yet
        err = s.login(accountPayload, createAccountRequest, rmp)
        if err != nil {
            return err
        }
    }

    messenger := s.backend.Messenger()
    if messenger == nil {
        return fmt.Errorf("messenger is nil when HandleRawMessage")
    }
    err = messenger.SetInstallationDeviceType(deviceType)
    if err != nil {
        return err
    }

    installations := GetMessengerInstallationsMap(messenger)

    err = messenger.HandleSyncRawMessages(rmp.rawMessages)

    if err != nil {
        return err
    }

    if newInstallation := FindNewInstallations(messenger, installations); newInstallation != nil {
        signal.SendLocalPairingEvent(Event{
            Type:   EventReceivedInstallation,
            Action: ActionPairingInstallation,
            Data:   newInstallation})
    }

    return nil
}

func (s *SyncRawMessageHandler) login(accountPayload *AccountPayload, createAccountRequest *requests.CreateAccount, rmp *RawMessagesPayload) error {
    account := accountPayload.multiaccount
    installationID := multidevice.GenerateInstallationID()
    nodeConfig, err := api.DefaultNodeConfig(installationID, createAccountRequest)
    if err != nil {
        return err
    }

    keystoreRelativePath, err := s.backend.InitKeyStoreDirWithAccount(nodeConfig.RootDataDir, account.KeyUID)
    nodeConfig.KeyStoreDir = keystoreRelativePath

    if err != nil {
        return err
    }

    var chatKey *ecdsa.PrivateKey
    if accountPayload.chatKey != "" {
        chatKeyHex := strings.Trim(accountPayload.chatKey, "0x")
        chatKey, err = ethcrypto.HexToECDSA(chatKeyHex)
        if err != nil {
            return err
        }
    }

    if accountPayload.exist {
        return s.backend.StartNodeWithAccount(*account, accountPayload.password, nodeConfig, chatKey)
    }

    // Override some of received settings
    rmp.setting.DeviceName = createAccountRequest.DeviceName
    rmp.setting.InstallationID = installationID
    rmp.setting.CurrentNetwork = api.DefaultCurrentNetwork

    return s.backend.StartNodeWithAccountAndInitialConfig(
        *account,
        accountPayload.password,
        *rmp.setting,
        nodeConfig,
        rmp.profileKeypair.Accounts,
        chatKey,
    )
}