2017-05-16 12:09:52 +00:00
|
|
|
package api
|
|
|
|
|
|
|
|
import (
|
2017-09-04 12:56:58 +00:00
|
|
|
"context"
|
2019-02-12 11:07:13 +00:00
|
|
|
"encoding/hex"
|
2018-03-22 12:31:12 +00:00
|
|
|
"errors"
|
2018-02-09 13:37:56 +00:00
|
|
|
"fmt"
|
2018-11-06 06:26:12 +00:00
|
|
|
"math/big"
|
2017-05-25 13:14:52 +00:00
|
|
|
"sync"
|
2019-03-29 10:20:24 +00:00
|
|
|
"time"
|
2017-05-25 13:14:52 +00:00
|
|
|
|
2019-03-28 14:56:21 +00:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2017-05-16 12:09:52 +00:00
|
|
|
gethcommon "github.com/ethereum/go-ethereum/common"
|
2018-08-16 11:37:53 +00:00
|
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
2019-01-24 15:44:46 +00:00
|
|
|
ethcrypto "github.com/ethereum/go-ethereum/crypto"
|
2019-03-29 10:20:24 +00:00
|
|
|
"github.com/ethereum/go-ethereum/ethclient"
|
2018-03-20 18:35:28 +00:00
|
|
|
"github.com/ethereum/go-ethereum/log"
|
2018-05-04 10:53:41 +00:00
|
|
|
gethnode "github.com/ethereum/go-ethereum/node"
|
2018-11-21 10:22:30 +00:00
|
|
|
"github.com/ethereum/go-ethereum/p2p/enode"
|
2018-06-08 11:29:50 +00:00
|
|
|
"github.com/status-im/status-go/account"
|
2019-03-29 10:20:24 +00:00
|
|
|
"github.com/status-im/status-go/mailserver/registry"
|
2018-06-08 11:29:50 +00:00
|
|
|
"github.com/status-im/status-go/node"
|
|
|
|
"github.com/status-im/status-go/notifications/push/fcm"
|
|
|
|
"github.com/status-im/status-go/params"
|
|
|
|
"github.com/status-im/status-go/rpc"
|
2018-04-10 10:02:54 +00:00
|
|
|
"github.com/status-im/status-go/services/personal"
|
2018-05-04 10:53:41 +00:00
|
|
|
"github.com/status-im/status-go/services/rpcfilters"
|
2018-09-24 18:07:34 +00:00
|
|
|
"github.com/status-im/status-go/services/shhext/chat"
|
2018-09-27 13:07:32 +00:00
|
|
|
"github.com/status-im/status-go/services/shhext/chat/crypto"
|
2018-11-06 06:26:12 +00:00
|
|
|
"github.com/status-im/status-go/services/typeddata"
|
2018-05-03 07:35:58 +00:00
|
|
|
"github.com/status-im/status-go/signal"
|
2018-06-08 11:29:50 +00:00
|
|
|
"github.com/status-im/status-go/transactions"
|
2017-10-10 15:30:56 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
//todo(jeka): should be removed
|
2019-03-29 10:20:24 +00:00
|
|
|
fcmServerKey = "AAAAxwa-r08:APA91bFtMIToDVKGAmVCm76iEXtA4dn9MPvLdYKIZqAlNpLJbd12EgdBI9DSDSXKdqvIAgLodepmRhGVaWvhxnXJzVpE6MoIRuKedDV3kfHSVBhWFqsyoLTwXY4xeufL9Sdzb581U-lx"
|
|
|
|
contractQueryTimeout = 1000 * time.Millisecond
|
2017-05-16 12:09:52 +00:00
|
|
|
)
|
|
|
|
|
2018-03-22 12:31:12 +00:00
|
|
|
var (
|
|
|
|
// ErrWhisperClearIdentitiesFailure clearing whisper identities has failed.
|
|
|
|
ErrWhisperClearIdentitiesFailure = errors.New("failed to clear whisper identities")
|
|
|
|
// ErrWhisperIdentityInjectionFailure injecting whisper identities has failed.
|
|
|
|
ErrWhisperIdentityInjectionFailure = errors.New("failed to inject identity into Whisper")
|
2018-08-16 11:37:53 +00:00
|
|
|
// ErrUnsupportedRPCMethod is for methods not supported by the RPC interface
|
|
|
|
ErrUnsupportedRPCMethod = errors.New("method is unsupported by RPC interface")
|
2018-12-20 08:31:17 +00:00
|
|
|
// ErrRPCClientUnavailable is returned if an RPC client can't be retrieved.
|
|
|
|
// This is a normal situation when a node is stopped.
|
|
|
|
ErrRPCClientUnavailable = errors.New("JSON-RPC client is unavailable")
|
2018-03-22 12:31:12 +00:00
|
|
|
)
|
|
|
|
|
2017-05-16 12:09:52 +00:00
|
|
|
// StatusBackend implements Status.im service
|
|
|
|
type StatusBackend struct {
|
2018-08-16 11:37:53 +00:00
|
|
|
mu sync.Mutex
|
|
|
|
statusNode *node.StatusNode
|
|
|
|
personalAPI *personal.PublicAPI
|
|
|
|
rpcFilters *rpcfilters.Service
|
|
|
|
accountManager *account.Manager
|
|
|
|
transactor *transactions.Transactor
|
|
|
|
newNotification fcm.NotificationConstructor
|
|
|
|
connectionState connectionState
|
|
|
|
appState appState
|
|
|
|
log log.Logger
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// NewStatusBackend create a new NewStatusBackend instance
|
|
|
|
func NewStatusBackend() *StatusBackend {
|
2018-11-28 11:05:18 +00:00
|
|
|
defer log.Info("Status backend initialized", "version", params.Version, "commit", params.GitCommit)
|
2017-05-16 12:09:52 +00:00
|
|
|
|
2018-04-05 09:45:26 +00:00
|
|
|
statusNode := node.New()
|
|
|
|
accountManager := account.NewManager(statusNode)
|
2018-08-16 11:37:53 +00:00
|
|
|
transactor := transactions.NewTransactor()
|
|
|
|
personalAPI := personal.NewAPI()
|
2017-10-18 20:56:39 +00:00
|
|
|
notificationManager := fcm.NewNotification(fcmServerKey)
|
2018-07-27 15:54:40 +00:00
|
|
|
rpcFilters := rpcfilters.New(statusNode)
|
2017-08-15 10:27:12 +00:00
|
|
|
|
2017-05-16 12:09:52 +00:00
|
|
|
return &StatusBackend{
|
2018-08-16 11:37:53 +00:00
|
|
|
statusNode: statusNode,
|
|
|
|
accountManager: accountManager,
|
|
|
|
transactor: transactor,
|
|
|
|
personalAPI: personalAPI,
|
|
|
|
rpcFilters: rpcFilters,
|
|
|
|
newNotification: notificationManager,
|
|
|
|
log: log.New("package", "status-go/api.StatusBackend"),
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-05 09:45:26 +00:00
|
|
|
// StatusNode returns reference to node manager
|
|
|
|
func (b *StatusBackend) StatusNode() *node.StatusNode {
|
|
|
|
return b.statusNode
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// AccountManager returns reference to account manager
|
2018-03-22 12:31:12 +00:00
|
|
|
func (b *StatusBackend) AccountManager() *account.Manager {
|
2018-02-14 16:32:36 +00:00
|
|
|
return b.accountManager
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
|
|
|
|
2018-04-09 08:18:22 +00:00
|
|
|
// Transactor returns reference to a status transactor
|
|
|
|
func (b *StatusBackend) Transactor() *transactions.Transactor {
|
|
|
|
return b.transactor
|
|
|
|
}
|
|
|
|
|
2017-05-16 12:09:52 +00:00
|
|
|
// IsNodeRunning confirm that node is running
|
2018-02-14 16:32:36 +00:00
|
|
|
func (b *StatusBackend) IsNodeRunning() bool {
|
2018-04-05 09:45:26 +00:00
|
|
|
return b.statusNode.IsRunning()
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// StartNode start Status node, fails if node is already started
|
2018-02-14 16:32:36 +00:00
|
|
|
func (b *StatusBackend) StartNode(config *params.NodeConfig) error {
|
|
|
|
b.mu.Lock()
|
|
|
|
defer b.mu.Unlock()
|
2018-04-20 15:39:53 +00:00
|
|
|
|
|
|
|
if err := b.startNode(config); err != nil {
|
2018-05-03 07:35:58 +00:00
|
|
|
signal.SendNodeCrashed(err)
|
2018-04-20 15:39:53 +00:00
|
|
|
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2018-02-09 13:37:56 +00:00
|
|
|
}
|
2017-05-25 13:14:52 +00:00
|
|
|
|
2018-05-04 10:53:41 +00:00
|
|
|
func (b *StatusBackend) rpcFiltersService() gethnode.ServiceConstructor {
|
|
|
|
return func(*gethnode.ServiceContext) (gethnode.Service, error) {
|
|
|
|
return rpcfilters.New(b.statusNode), nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-14 16:32:36 +00:00
|
|
|
func (b *StatusBackend) startNode(config *params.NodeConfig) (err error) {
|
2018-02-09 13:37:56 +00:00
|
|
|
defer func() {
|
|
|
|
if r := recover(); r != nil {
|
|
|
|
err = fmt.Errorf("node crashed on start: %v", err)
|
|
|
|
}
|
|
|
|
}()
|
2018-04-12 16:17:10 +00:00
|
|
|
|
2018-09-13 16:31:29 +00:00
|
|
|
// Start by validating configuration
|
|
|
|
if err := config.Validate(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2018-05-04 10:53:41 +00:00
|
|
|
services := []gethnode.ServiceConstructor{}
|
|
|
|
services = appendIf(config.UpstreamConfig.Enabled, services, b.rpcFiltersService())
|
|
|
|
|
2019-01-02 18:57:36 +00:00
|
|
|
if err = b.statusNode.StartWithOptions(config, node.StartOptions{
|
|
|
|
Services: services,
|
|
|
|
// The peers discovery protocols are started manually after
|
|
|
|
// `node.ready` signal is sent.
|
|
|
|
// It was discussed in https://github.com/status-im/status-go/pull/1333.
|
|
|
|
StartDiscovery: false,
|
|
|
|
}); err != nil {
|
2018-04-20 15:39:53 +00:00
|
|
|
return
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
2018-05-03 07:35:58 +00:00
|
|
|
signal.SendNodeStarted()
|
2018-04-09 08:18:22 +00:00
|
|
|
|
|
|
|
b.transactor.SetNetworkID(config.NetworkID)
|
2018-04-10 10:02:54 +00:00
|
|
|
b.transactor.SetRPC(b.statusNode.RPCClient(), rpc.DefaultCallTimeout)
|
2018-04-18 11:04:02 +00:00
|
|
|
b.personalAPI.SetRPC(b.statusNode.RPCPrivateClient(), rpc.DefaultCallTimeout)
|
2018-04-20 15:39:53 +00:00
|
|
|
|
|
|
|
if err = b.registerHandlers(); err != nil {
|
2018-03-20 18:35:28 +00:00
|
|
|
b.log.Error("Handler registration failed", "err", err)
|
2018-04-20 15:39:53 +00:00
|
|
|
return
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
2018-04-20 15:39:53 +00:00
|
|
|
b.log.Info("Handlers registered")
|
|
|
|
|
2018-06-27 08:11:45 +00:00
|
|
|
if err = b.reSelectAccount(); err != nil {
|
2018-03-20 18:35:28 +00:00
|
|
|
b.log.Error("Reselect account failed", "err", err)
|
2018-04-20 15:39:53 +00:00
|
|
|
return
|
2017-10-20 09:06:22 +00:00
|
|
|
}
|
2018-03-20 18:35:28 +00:00
|
|
|
b.log.Info("Account reselected")
|
2018-04-20 15:39:53 +00:00
|
|
|
|
2018-05-03 10:36:56 +00:00
|
|
|
if st, err := b.statusNode.StatusService(); err == nil {
|
|
|
|
st.SetAccountManager(b.AccountManager())
|
|
|
|
}
|
|
|
|
|
2018-07-16 07:40:40 +00:00
|
|
|
if st, err := b.statusNode.PeerService(); err == nil {
|
|
|
|
st.SetDiscoverer(b.StatusNode())
|
|
|
|
}
|
|
|
|
|
2018-05-03 07:35:58 +00:00
|
|
|
signal.SendNodeReady()
|
2018-04-20 15:39:53 +00:00
|
|
|
|
2019-01-02 18:57:36 +00:00
|
|
|
if err := b.statusNode.StartDiscovery(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2018-02-09 13:37:56 +00:00
|
|
|
return nil
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// StopNode stop Status node. Stopped node cannot be resumed.
|
2018-02-14 16:32:36 +00:00
|
|
|
func (b *StatusBackend) StopNode() error {
|
|
|
|
b.mu.Lock()
|
|
|
|
defer b.mu.Unlock()
|
|
|
|
return b.stopNode()
|
2018-02-09 13:37:56 +00:00
|
|
|
}
|
2017-05-16 12:09:52 +00:00
|
|
|
|
2018-02-14 16:32:36 +00:00
|
|
|
func (b *StatusBackend) stopNode() error {
|
|
|
|
if !b.IsNodeRunning() {
|
2018-02-09 13:37:56 +00:00
|
|
|
return node.ErrNoRunningNode
|
2017-05-25 13:14:52 +00:00
|
|
|
}
|
2018-05-03 07:35:58 +00:00
|
|
|
defer signal.SendNodeStopped()
|
2018-04-05 09:45:26 +00:00
|
|
|
return b.statusNode.Stop()
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
|
|
|
|
2017-05-25 13:14:52 +00:00
|
|
|
// RestartNode restart running Status node, fails if node is not running
|
2018-02-14 16:32:36 +00:00
|
|
|
func (b *StatusBackend) RestartNode() error {
|
2018-04-20 15:39:53 +00:00
|
|
|
b.mu.Lock()
|
|
|
|
defer b.mu.Unlock()
|
|
|
|
|
2018-02-14 16:32:36 +00:00
|
|
|
if !b.IsNodeRunning() {
|
2018-02-09 13:37:56 +00:00
|
|
|
return node.ErrNoRunningNode
|
2017-05-25 13:14:52 +00:00
|
|
|
}
|
2018-04-20 15:39:53 +00:00
|
|
|
|
2018-04-16 12:36:09 +00:00
|
|
|
newcfg := *(b.statusNode.Config())
|
2018-02-14 16:32:36 +00:00
|
|
|
if err := b.stopNode(); err != nil {
|
2018-02-09 13:37:56 +00:00
|
|
|
return err
|
|
|
|
}
|
2018-02-14 16:32:36 +00:00
|
|
|
return b.startNode(&newcfg)
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
|
|
|
|
2017-05-25 13:14:52 +00:00
|
|
|
// ResetChainData remove chain data from data directory.
|
|
|
|
// Node is stopped, and new node is started, with clean data directory.
|
2018-02-14 16:32:36 +00:00
|
|
|
func (b *StatusBackend) ResetChainData() error {
|
|
|
|
b.mu.Lock()
|
|
|
|
defer b.mu.Unlock()
|
2018-04-16 12:36:09 +00:00
|
|
|
newcfg := *(b.statusNode.Config())
|
2018-02-14 16:32:36 +00:00
|
|
|
if err := b.stopNode(); err != nil {
|
2018-02-09 13:37:56 +00:00
|
|
|
return err
|
|
|
|
}
|
2018-02-14 16:32:36 +00:00
|
|
|
// config is cleaned when node is stopped
|
2018-04-05 09:45:26 +00:00
|
|
|
if err := b.statusNode.ResetChainData(&newcfg); err != nil {
|
2018-02-09 13:37:56 +00:00
|
|
|
return err
|
|
|
|
}
|
2018-05-03 07:35:58 +00:00
|
|
|
signal.SendChainDataRemoved()
|
2018-02-14 16:32:36 +00:00
|
|
|
return b.startNode(&newcfg)
|
2017-05-16 12:09:52 +00:00
|
|
|
}
|
|
|
|
|
2018-04-16 08:01:37 +00:00
|
|
|
// CallRPC executes public RPC requests on node's in-proc RPC server.
|
2018-12-20 08:31:17 +00:00
|
|
|
func (b *StatusBackend) CallRPC(inputJSON string) (string, error) {
|
2018-04-05 09:45:26 +00:00
|
|
|
client := b.statusNode.RPCClient()
|
2018-12-20 08:31:17 +00:00
|
|
|
if client == nil {
|
|
|
|
return "", ErrRPCClientUnavailable
|
|
|
|
}
|
|
|
|
return client.CallRaw(inputJSON), nil
|
2017-05-28 13:57:30 +00:00
|
|
|
}
|
|
|
|
|
2019-03-29 17:49:01 +00:00
|
|
|
// GetNodesFromContract returns a list of nodes from the contract
|
2019-03-29 10:20:24 +00:00
|
|
|
func (b *StatusBackend) GetNodesFromContract(rpcEndpoint string, contractAddress string) ([]string, error) {
|
|
|
|
var response []string
|
|
|
|
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), contractQueryTimeout)
|
|
|
|
defer cancel()
|
|
|
|
|
|
|
|
ethclient, err := ethclient.DialContext(ctx, rpcEndpoint)
|
|
|
|
if err != nil {
|
|
|
|
return response, err
|
|
|
|
}
|
|
|
|
|
|
|
|
contract, err := registry.NewNodes(gethcommon.HexToAddress(contractAddress), ethclient)
|
|
|
|
if err != nil {
|
|
|
|
return response, err
|
|
|
|
}
|
|
|
|
|
2019-03-29 17:49:01 +00:00
|
|
|
nodeCount, err := contract.NodeCount(nil)
|
2019-03-29 10:20:24 +00:00
|
|
|
if err != nil {
|
|
|
|
return response, err
|
|
|
|
}
|
|
|
|
|
2019-03-29 17:49:01 +00:00
|
|
|
one := big.NewInt(1)
|
|
|
|
for i := big.NewInt(0); i.Cmp(nodeCount) < 0; i.Add(i, one) {
|
|
|
|
node, err := contract.Nodes(nil, i)
|
|
|
|
if err != nil {
|
|
|
|
return response, err
|
|
|
|
}
|
|
|
|
response = append(response, node)
|
|
|
|
}
|
|
|
|
|
2019-03-29 10:20:24 +00:00
|
|
|
return response, nil
|
|
|
|
}
|
|
|
|
|
2018-04-16 08:01:37 +00:00
|
|
|
// CallPrivateRPC executes public and private RPC requests on node's in-proc RPC server.
|
2018-12-20 08:31:17 +00:00
|
|
|
func (b *StatusBackend) CallPrivateRPC(inputJSON string) (string, error) {
|
2018-04-16 08:01:37 +00:00
|
|
|
client := b.statusNode.RPCPrivateClient()
|
2018-12-20 08:31:17 +00:00
|
|
|
if client == nil {
|
|
|
|
return "", ErrRPCClientUnavailable
|
|
|
|
}
|
|
|
|
return client.CallRaw(inputJSON), nil
|
2018-04-16 08:01:37 +00:00
|
|
|
}
|
|
|
|
|
2017-09-04 12:56:58 +00:00
|
|
|
// SendTransaction creates a new transaction and waits until it's complete.
|
2018-08-16 11:37:53 +00:00
|
|
|
func (b *StatusBackend) SendTransaction(sendArgs transactions.SendTxArgs, password string) (hash gethcommon.Hash, err error) {
|
2019-01-09 08:47:06 +00:00
|
|
|
verifiedAccount, err := b.getVerifiedWalletAccount(password)
|
2018-08-16 11:37:53 +00:00
|
|
|
if err != nil {
|
|
|
|
return hash, err
|
|
|
|
}
|
|
|
|
|
|
|
|
hash, err = b.transactor.SendTransaction(sendArgs, verifiedAccount)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
go b.rpcFilters.TriggerTransactionSentToUpstreamEvent(hash)
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-02-15 11:31:20 +00:00
|
|
|
func (b *StatusBackend) SendTransactionWithSignature(sendArgs transactions.SendTxArgs, sig []byte) (hash gethcommon.Hash, err error) {
|
|
|
|
hash, err = b.transactor.SendTransactionWithSignature(sendArgs, sig)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
go b.rpcFilters.TriggerTransactionSentToUpstreamEvent(hash)
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-02-21 09:53:39 +00:00
|
|
|
// HashTransaction validate the transaction and returns new sendArgs and the transaction hash.
|
|
|
|
func (b *StatusBackend) HashTransaction(sendArgs transactions.SendTxArgs) (transactions.SendTxArgs, gethcommon.Hash, error) {
|
|
|
|
return b.transactor.HashTransaction(sendArgs)
|
|
|
|
}
|
|
|
|
|
2018-08-16 11:37:53 +00:00
|
|
|
// SignMessage checks the pwd vs the selected account and passes on the signParams
|
|
|
|
// to personalAPI for message signature
|
|
|
|
func (b *StatusBackend) SignMessage(rpcParams personal.SignParams) (hexutil.Bytes, error) {
|
2019-01-09 08:47:06 +00:00
|
|
|
verifiedAccount, err := b.getVerifiedWalletAccount(rpcParams.Password)
|
2018-08-16 11:37:53 +00:00
|
|
|
if err != nil {
|
|
|
|
return hexutil.Bytes{}, err
|
2018-07-27 15:54:40 +00:00
|
|
|
}
|
2018-08-16 11:37:53 +00:00
|
|
|
return b.personalAPI.Sign(rpcParams, verifiedAccount)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Recover calls the personalAPI to return address associated with the private
|
|
|
|
// key that was used to calculate the signature in the message
|
|
|
|
func (b *StatusBackend) Recover(rpcParams personal.RecoverParams) (gethcommon.Address, error) {
|
|
|
|
return b.personalAPI.Recover(rpcParams)
|
2017-09-04 12:56:58 +00:00
|
|
|
}
|
|
|
|
|
2018-11-06 06:26:12 +00:00
|
|
|
// SignTypedData accepts data and password. Gets verified account and signs typed data.
|
|
|
|
func (b *StatusBackend) SignTypedData(typed typeddata.TypedData, password string) (hexutil.Bytes, error) {
|
2019-01-09 08:47:06 +00:00
|
|
|
account, err := b.getVerifiedWalletAccount(password)
|
2018-11-06 06:26:12 +00:00
|
|
|
if err != nil {
|
|
|
|
return hexutil.Bytes{}, err
|
|
|
|
}
|
|
|
|
chain := new(big.Int).SetUint64(b.StatusNode().Config().NetworkID)
|
|
|
|
sig, err := typeddata.Sign(typed, account.AccountKey.PrivateKey, chain)
|
|
|
|
if err != nil {
|
|
|
|
return hexutil.Bytes{}, err
|
|
|
|
}
|
|
|
|
return hexutil.Bytes(sig), err
|
|
|
|
}
|
|
|
|
|
2019-03-28 14:56:21 +00:00
|
|
|
// HashTypedData generates the hash of TypedData.
|
|
|
|
func (b *StatusBackend) HashTypedData(typed typeddata.TypedData) (common.Hash, error) {
|
|
|
|
chain := new(big.Int).SetUint64(b.StatusNode().Config().NetworkID)
|
|
|
|
hash, err := typeddata.ValidateAndHash(typed, chain)
|
|
|
|
if err != nil {
|
|
|
|
return common.Hash{}, err
|
|
|
|
}
|
|
|
|
return hash, err
|
|
|
|
}
|
|
|
|
|
2019-01-09 08:47:06 +00:00
|
|
|
func (b *StatusBackend) getVerifiedWalletAccount(password string) (*account.SelectedExtKey, error) {
|
|
|
|
selectedWalletAccount, err := b.accountManager.SelectedWalletAccount()
|
2018-03-26 15:53:10 +00:00
|
|
|
if err != nil {
|
|
|
|
b.log.Error("failed to get a selected account", "err", err)
|
|
|
|
return nil, err
|
|
|
|
}
|
2018-04-16 12:36:09 +00:00
|
|
|
config := b.StatusNode().Config()
|
2019-01-09 08:47:06 +00:00
|
|
|
_, err = b.accountManager.VerifyAccountPassword(config.KeyStoreDir, selectedWalletAccount.Address.String(), password)
|
2018-03-26 15:53:10 +00:00
|
|
|
if err != nil {
|
2019-01-09 08:47:06 +00:00
|
|
|
b.log.Error("failed to verify account", "account", selectedWalletAccount.Address.String(), "error", err)
|
2018-03-26 15:53:10 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
2019-01-09 08:47:06 +00:00
|
|
|
return selectedWalletAccount, nil
|
2018-03-26 15:53:10 +00:00
|
|
|
}
|
|
|
|
|
2017-05-16 12:09:52 +00:00
|
|
|
// registerHandlers attaches Status callback handlers to running node
|
2018-02-14 16:32:36 +00:00
|
|
|
func (b *StatusBackend) registerHandlers() error {
|
2018-08-07 14:21:43 +00:00
|
|
|
var clients []*rpc.Client
|
|
|
|
|
|
|
|
if c := b.StatusNode().RPCClient(); c != nil {
|
|
|
|
clients = append(clients, c)
|
|
|
|
} else {
|
2018-04-16 12:36:09 +00:00
|
|
|
return errors.New("RPC client unavailable")
|
2017-10-26 13:25:38 +00:00
|
|
|
}
|
2018-04-09 08:18:22 +00:00
|
|
|
|
2018-08-07 14:21:43 +00:00
|
|
|
if c := b.StatusNode().RPCPrivateClient(); c != nil {
|
|
|
|
clients = append(clients, c)
|
|
|
|
} else {
|
|
|
|
return errors.New("RPC private client unavailable")
|
|
|
|
}
|
2018-04-09 08:18:22 +00:00
|
|
|
|
2018-08-07 14:21:43 +00:00
|
|
|
for _, client := range clients {
|
|
|
|
client.RegisterHandler(
|
|
|
|
params.AccountsMethodName,
|
|
|
|
func(context.Context, ...interface{}) (interface{}, error) {
|
|
|
|
return b.AccountManager().Accounts()
|
|
|
|
},
|
|
|
|
)
|
|
|
|
|
2018-08-16 11:37:53 +00:00
|
|
|
client.RegisterHandler(params.SendTransactionMethodName, unsupportedMethodHandler)
|
|
|
|
client.RegisterHandler(params.PersonalSignMethodName, unsupportedMethodHandler)
|
|
|
|
client.RegisterHandler(params.PersonalRecoverMethodName, unsupportedMethodHandler)
|
2018-08-07 14:21:43 +00:00
|
|
|
}
|
2018-04-10 10:02:54 +00:00
|
|
|
|
2017-05-16 12:09:52 +00:00
|
|
|
return nil
|
|
|
|
}
|
2018-02-09 20:28:16 +00:00
|
|
|
|
2018-08-16 11:37:53 +00:00
|
|
|
func unsupportedMethodHandler(ctx context.Context, rpcParams ...interface{}) (interface{}, error) {
|
|
|
|
return nil, ErrUnsupportedRPCMethod
|
|
|
|
}
|
|
|
|
|
2018-02-09 20:28:16 +00:00
|
|
|
// ConnectionChange handles network state changes logic.
|
2018-04-23 13:34:49 +00:00
|
|
|
func (b *StatusBackend) ConnectionChange(typ string, expensive bool) {
|
2018-04-20 15:39:53 +00:00
|
|
|
b.mu.Lock()
|
|
|
|
defer b.mu.Unlock()
|
|
|
|
|
2018-06-27 08:11:45 +00:00
|
|
|
state := connectionState{
|
|
|
|
Type: newConnectionType(typ),
|
2018-04-23 13:34:49 +00:00
|
|
|
Expensive: expensive,
|
|
|
|
}
|
2018-06-27 08:11:45 +00:00
|
|
|
if typ == none {
|
2018-04-23 13:34:49 +00:00
|
|
|
state.Offline = true
|
|
|
|
}
|
|
|
|
|
2018-03-20 18:35:28 +00:00
|
|
|
b.log.Info("Network state change", "old", b.connectionState, "new", state)
|
2018-04-23 13:34:49 +00:00
|
|
|
|
2018-02-16 13:58:13 +00:00
|
|
|
b.connectionState = state
|
2018-02-09 20:28:16 +00:00
|
|
|
|
|
|
|
// logic of handling state changes here
|
|
|
|
// restart node? force peers reconnect? etc
|
|
|
|
}
|
2018-03-14 15:46:21 +00:00
|
|
|
|
|
|
|
// AppStateChange handles app state changes (background/foreground).
|
2018-04-23 13:34:49 +00:00
|
|
|
// state values: see https://facebook.github.io/react-native/docs/appstate.html
|
|
|
|
func (b *StatusBackend) AppStateChange(state string) {
|
2018-06-27 08:11:45 +00:00
|
|
|
s, err := parseAppState(state)
|
2018-04-23 13:34:49 +00:00
|
|
|
if err != nil {
|
|
|
|
log.Error("AppStateChange failed, ignoring", "error", err)
|
|
|
|
return // and do nothing
|
|
|
|
}
|
|
|
|
|
2018-06-27 08:11:45 +00:00
|
|
|
b.log.Info("App State changed", "new-state", s)
|
|
|
|
b.appState = s
|
2018-03-14 15:46:21 +00:00
|
|
|
|
|
|
|
// TODO: put node in low-power mode if the app is in background (or inactive)
|
|
|
|
// and normal mode if the app is in foreground.
|
|
|
|
}
|
2018-03-22 12:31:12 +00:00
|
|
|
|
|
|
|
// Logout clears whisper identities.
|
|
|
|
func (b *StatusBackend) Logout() error {
|
2018-05-26 07:37:13 +00:00
|
|
|
b.mu.Lock()
|
|
|
|
defer b.mu.Unlock()
|
|
|
|
|
2018-04-05 09:45:26 +00:00
|
|
|
whisperService, err := b.statusNode.WhisperService()
|
2018-04-20 15:39:53 +00:00
|
|
|
switch err {
|
|
|
|
case node.ErrServiceUnknown: // Whisper was never registered
|
|
|
|
case nil:
|
|
|
|
if err := whisperService.DeleteKeyPairs(); err != nil {
|
|
|
|
return fmt.Errorf("%s: %v", ErrWhisperClearIdentitiesFailure, err)
|
|
|
|
}
|
|
|
|
default:
|
2018-03-22 12:31:12 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2018-04-20 15:39:53 +00:00
|
|
|
b.AccountManager().Logout()
|
|
|
|
|
|
|
|
return nil
|
2018-03-22 12:31:12 +00:00
|
|
|
}
|
|
|
|
|
2018-06-27 08:11:45 +00:00
|
|
|
// reSelectAccount selects previously selected account, often, after node restart.
|
|
|
|
func (b *StatusBackend) reSelectAccount() error {
|
2019-01-09 08:47:06 +00:00
|
|
|
selectedChatAccount, err := b.AccountManager().SelectedChatAccount()
|
|
|
|
if selectedChatAccount == nil || err == account.ErrNoAccountSelected {
|
2018-03-22 12:31:12 +00:00
|
|
|
return nil
|
|
|
|
}
|
2019-01-09 08:47:06 +00:00
|
|
|
|
2018-04-05 09:45:26 +00:00
|
|
|
whisperService, err := b.statusNode.WhisperService()
|
2018-04-20 15:39:53 +00:00
|
|
|
switch err {
|
|
|
|
case node.ErrServiceUnknown: // Whisper was never registered
|
|
|
|
case nil:
|
2019-01-09 08:47:06 +00:00
|
|
|
if err := whisperService.SelectKeyPair(selectedChatAccount.AccountKey.PrivateKey); err != nil {
|
2018-04-20 15:39:53 +00:00
|
|
|
return ErrWhisperIdentityInjectionFailure
|
|
|
|
}
|
|
|
|
default:
|
2018-03-22 12:31:12 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-01-18 09:01:14 +00:00
|
|
|
// SelectAccount selects current wallet and chat accounts, by verifying that each address has corresponding account which can be decrypted
|
|
|
|
// using provided password. Once verification is done, the decrypted chat key is injected into Whisper (as a single identity,
|
2018-03-22 12:31:12 +00:00
|
|
|
// all previous identities are removed).
|
2019-01-18 09:01:14 +00:00
|
|
|
func (b *StatusBackend) SelectAccount(walletAddress, chatAddress, password string) error {
|
2018-05-26 07:37:13 +00:00
|
|
|
b.mu.Lock()
|
|
|
|
defer b.mu.Unlock()
|
|
|
|
|
2019-01-18 09:01:14 +00:00
|
|
|
err := b.accountManager.SelectAccount(walletAddress, chatAddress, password)
|
2018-03-22 12:31:12 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-01-18 09:01:14 +00:00
|
|
|
|
2019-01-09 08:47:06 +00:00
|
|
|
chatAccount, err := b.accountManager.SelectedChatAccount()
|
2018-03-22 12:31:12 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2018-04-05 09:45:26 +00:00
|
|
|
whisperService, err := b.statusNode.WhisperService()
|
2018-04-20 15:39:53 +00:00
|
|
|
switch err {
|
|
|
|
case node.ErrServiceUnknown: // Whisper was never registered
|
|
|
|
case nil:
|
2019-01-09 08:47:06 +00:00
|
|
|
if err := whisperService.SelectKeyPair(chatAccount.AccountKey.PrivateKey); err != nil {
|
2018-04-20 15:39:53 +00:00
|
|
|
return ErrWhisperIdentityInjectionFailure
|
|
|
|
}
|
|
|
|
default:
|
2018-03-22 12:31:12 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2018-09-24 18:07:34 +00:00
|
|
|
if whisperService != nil {
|
|
|
|
st, err := b.statusNode.ShhExtService()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-01-25 10:31:51 +00:00
|
|
|
if err := st.InitProtocolWithPassword(chatAddress, password); err != nil {
|
2018-09-27 13:07:32 +00:00
|
|
|
return err
|
2018-09-24 18:07:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-22 12:31:12 +00:00
|
|
|
return nil
|
|
|
|
}
|
2018-04-23 13:34:49 +00:00
|
|
|
|
2019-01-18 13:03:32 +00:00
|
|
|
// SendDataNotification sends data push notifications to users.
|
|
|
|
// dataPayloadJSON is a JSON string that looks like this:
|
|
|
|
// {
|
|
|
|
// "data": {
|
|
|
|
// "msg-v2": {
|
|
|
|
// "from": "0x2cea3bd5", // hash of sender (first 10 characters/4 bytes of sha3 hash)
|
|
|
|
// "to": "0xb1f89744", // hash of recipient (first 10 characters/4 bytes of sha3 hash)
|
|
|
|
// "id": "0x872653ad", // message ID hash (first 10 characters/4 bytes of sha3 hash)
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
// }
|
|
|
|
func (b *StatusBackend) SendDataNotification(dataPayloadJSON string, tokens ...string) error {
|
|
|
|
log.Debug("sending data push notification")
|
|
|
|
|
|
|
|
err := b.newNotification().Send(dataPayloadJSON, tokens...)
|
2018-04-23 13:34:49 +00:00
|
|
|
if err != nil {
|
2019-01-18 13:03:32 +00:00
|
|
|
b.log.Error("SendDataNotification failed", "dataPayloadJSON", dataPayloadJSON, "error", err)
|
2018-04-23 13:34:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return err
|
|
|
|
}
|
2018-05-04 10:53:41 +00:00
|
|
|
|
2019-01-24 15:44:46 +00:00
|
|
|
// InjectChatAccount selects the current chat account using chatKeyHex and injects the key into whisper.
|
|
|
|
func (b *StatusBackend) InjectChatAccount(chatKeyHex, encryptionKeyHex string) error {
|
|
|
|
b.mu.Lock()
|
|
|
|
defer b.mu.Unlock()
|
|
|
|
|
|
|
|
b.accountManager.Logout()
|
|
|
|
|
|
|
|
chatKey, err := ethcrypto.HexToECDSA(chatKeyHex)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
b.accountManager.SetChatAccount(chatKey)
|
|
|
|
chatAccount, err := b.accountManager.SelectedChatAccount()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
whisperService, err := b.statusNode.WhisperService()
|
|
|
|
switch err {
|
|
|
|
case node.ErrServiceUnknown: // Whisper was never registered
|
|
|
|
case nil:
|
|
|
|
if err := whisperService.SelectKeyPair(chatAccount.AccountKey.PrivateKey); err != nil {
|
|
|
|
return ErrWhisperIdentityInjectionFailure
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if whisperService != nil {
|
|
|
|
st, err := b.statusNode.ShhExtService()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-01-25 10:31:51 +00:00
|
|
|
if err := st.InitProtocolWithEncyptionKey(chatAccount.Address.Hex(), encryptionKeyHex); err != nil {
|
2019-01-24 15:44:46 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-05-04 10:53:41 +00:00
|
|
|
func appendIf(condition bool, services []gethnode.ServiceConstructor, service gethnode.ServiceConstructor) []gethnode.ServiceConstructor {
|
|
|
|
if !condition {
|
|
|
|
return services
|
|
|
|
}
|
|
|
|
return append(services, service)
|
|
|
|
}
|
2018-09-24 18:07:34 +00:00
|
|
|
|
|
|
|
// CreateContactCode create or return the latest contact code
|
|
|
|
func (b *StatusBackend) CreateContactCode() (string, error) {
|
2019-01-09 08:47:06 +00:00
|
|
|
selectedChatAccount, err := b.AccountManager().SelectedChatAccount()
|
2018-09-24 18:07:34 +00:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
st, err := b.statusNode.ShhExtService()
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
2019-01-09 08:47:06 +00:00
|
|
|
bundle, err := st.GetBundle(selectedChatAccount.AccountKey.PrivateKey)
|
2018-09-24 18:07:34 +00:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
return bundle.ToBase64()
|
|
|
|
}
|
|
|
|
|
2019-02-12 11:07:13 +00:00
|
|
|
// GetContactCode return the latest contact code
|
|
|
|
func (b *StatusBackend) GetContactCode(identity string) (string, error) {
|
|
|
|
st, err := b.statusNode.ShhExtService()
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
publicKeyBytes, err := hex.DecodeString(identity)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
publicKey, err := ethcrypto.UnmarshalPubkey(publicKeyBytes)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
bundle, err := st.GetPublicBundle(publicKey)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
if bundle == nil {
|
|
|
|
return "", nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return bundle.ToBase64()
|
|
|
|
}
|
|
|
|
|
2018-09-24 18:07:34 +00:00
|
|
|
// ProcessContactCode process and adds the someone else's bundle
|
|
|
|
func (b *StatusBackend) ProcessContactCode(contactCode string) error {
|
2019-01-09 08:47:06 +00:00
|
|
|
selectedChatAccount, err := b.AccountManager().SelectedChatAccount()
|
2018-09-24 18:07:34 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
st, err := b.statusNode.ShhExtService()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
bundle, err := chat.FromBase64(contactCode)
|
|
|
|
if err != nil {
|
|
|
|
b.log.Error("error decoding base64", "err", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-01-09 08:47:06 +00:00
|
|
|
if _, err := st.ProcessPublicBundle(selectedChatAccount.AccountKey.PrivateKey, bundle); err != nil {
|
2018-09-24 18:07:34 +00:00
|
|
|
b.log.Error("error adding bundle", "err", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// ExtractIdentityFromContactCode extract the identity of the user generating the contact code
|
|
|
|
func (b *StatusBackend) ExtractIdentityFromContactCode(contactCode string) (string, error) {
|
|
|
|
bundle, err := chat.FromBase64(contactCode)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
return chat.ExtractIdentity(bundle)
|
|
|
|
}
|
2018-09-27 13:07:32 +00:00
|
|
|
|
2018-10-04 16:53:48 +00:00
|
|
|
// ExtractGroupMembershipSignatures extract signatures from tuples of content/signature
|
|
|
|
func (b *StatusBackend) ExtractGroupMembershipSignatures(signaturePairs [][2]string) ([]string, error) {
|
|
|
|
return crypto.ExtractSignatures(signaturePairs)
|
|
|
|
}
|
|
|
|
|
2018-09-27 13:07:32 +00:00
|
|
|
// SignGroupMembership signs a piece of data containing membership information
|
|
|
|
func (b *StatusBackend) SignGroupMembership(content string) (string, error) {
|
2019-01-09 08:47:06 +00:00
|
|
|
selectedChatAccount, err := b.AccountManager().SelectedChatAccount()
|
2018-09-27 13:07:32 +00:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
2019-01-09 08:47:06 +00:00
|
|
|
return crypto.Sign(content, selectedChatAccount.AccountKey.PrivateKey)
|
2018-09-27 13:07:32 +00:00
|
|
|
}
|
2018-11-06 08:05:32 +00:00
|
|
|
|
|
|
|
// EnableInstallation enables an installation for multi-device sync.
|
|
|
|
func (b *StatusBackend) EnableInstallation(installationID string) error {
|
2019-01-09 08:47:06 +00:00
|
|
|
selectedChatAccount, err := b.AccountManager().SelectedChatAccount()
|
2018-11-06 08:05:32 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
st, err := b.statusNode.ShhExtService()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-01-09 08:47:06 +00:00
|
|
|
if err := st.EnableInstallation(&selectedChatAccount.AccountKey.PrivateKey.PublicKey, installationID); err != nil {
|
2018-11-06 08:05:32 +00:00
|
|
|
b.log.Error("error enabling installation", "err", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// DisableInstallation disables an installation for multi-device sync.
|
|
|
|
func (b *StatusBackend) DisableInstallation(installationID string) error {
|
2019-01-09 08:47:06 +00:00
|
|
|
selectedChatAccount, err := b.AccountManager().SelectedChatAccount()
|
2018-11-06 08:05:32 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
st, err := b.statusNode.ShhExtService()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-01-09 08:47:06 +00:00
|
|
|
if err := st.DisableInstallation(&selectedChatAccount.AccountKey.PrivateKey.PublicKey, installationID); err != nil {
|
2018-11-06 08:05:32 +00:00
|
|
|
b.log.Error("error disabling installation", "err", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2018-11-21 10:22:30 +00:00
|
|
|
|
|
|
|
// UpdateMailservers on ShhExtService.
|
|
|
|
func (b *StatusBackend) UpdateMailservers(enodes []string) error {
|
|
|
|
st, err := b.statusNode.ShhExtService()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
nodes := make([]*enode.Node, len(enodes))
|
|
|
|
for i, rawurl := range enodes {
|
|
|
|
node, err := enode.ParseV4(rawurl)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
nodes[i] = node
|
|
|
|
}
|
2018-12-12 09:39:00 +00:00
|
|
|
return st.UpdateMailservers(nodes)
|
2018-11-21 10:22:30 +00:00
|
|
|
}
|