Fixed eth_sendTransaction routing to the local node

geth/api/backend.go

@@ -5,7 +5,6 @@ import (
 	"sync"
 
 	gethcommon "github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/les"
 	"github.com/status-im/status-go/geth/common"
 	"github.com/status-im/status-go/geth/jail"
 	"github.com/status-im/status-go/geth/log"
@@ -224,19 +223,9 @@ func (m *StatusBackend) DiscardTransactions(ids []common.QueuedTxID) map[common.
 
 // registerHandlers attaches Status callback handlers to running node
 func (m *StatusBackend) registerHandlers() error {
-	runningNode, err := m.nodeManager.Node()
-	if err != nil {
-		return err
-	}
-
-	var lightEthereum *les.LightEthereum
-	if err := runningNode.Service(&lightEthereum); err != nil {
-		log.Error("Cannot get light ethereum service", "error", err)
-		return err
-	}
-
-	lightEthereum.StatusBackend.SetAccountsFilterHandler(m.accountManager.AccountsListRequestHandler())
-	log.Info("Registered handler", "fn", "AccountsFilterHandler")
+	rpcClient := m.NodeManager().RPCClient()
+	rpcClient.RegisterHandler("eth_accounts", m.accountManager.AccountsRPCHandler())
+	rpcClient.RegisterHandler("eth_sendTransaction", m.txQueueManager.SendTransactionRPCHandler)
 
 	m.txQueueManager.SetTransactionQueueHandler(m.txQueueManager.TransactionQueueHandler())
 	log.Info("Registered handler", "fn", "TransactionQueueHandler")

geth/api/backend_accounts_test.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/ethereum/go-ethereum/les"
 	"github.com/status-im/status-go/geth/common"
 	"github.com/status-im/status-go/geth/node"
 	"github.com/status-im/status-go/geth/params"
@@ -22,14 +21,8 @@ func (s *BackendTestSuite) TestAccountsList() {
 	require.NoError(err)
 	require.NotNil(runningNode)
 
-	var lesService *les.LightEthereum
-	require.NoError(runningNode.Service(&lesService))
-	require.NotNil(lesService)
-
-	accounts := lesService.StatusBackend.AccountManager().Accounts()
-	for _, acc := range accounts {
-		fmt.Println(acc.Hex())
-	}
+	accounts, err := s.backend.AccountManager().Accounts()
+	require.NoError(err)
 
 	// make sure that we start with empty accounts list (nobody has logged in yet)
 	require.Zero(len(accounts), "accounts returned, while there should be none (we haven't logged in yet)")
@@ -39,15 +32,17 @@ func (s *BackendTestSuite) TestAccountsList() {
 	require.NoError(err)
 
 	// ensure that there is still no accounts returned
-	accounts = lesService.StatusBackend.AccountManager().Accounts()
+	accounts, err = s.backend.AccountManager().Accounts()
+	require.NoError(err)
 	require.Zero(len(accounts), "accounts returned, while there should be none (we haven't logged in yet)")
 
 	// select account (sub-accounts will be created for this key)
 	err = s.backend.AccountManager().SelectAccount(address, TestConfig.Account1.Password)
 	require.NoError(err, "account selection failed")
 
 	// at this point main account should show up
-	accounts = lesService.StatusBackend.AccountManager().Accounts()
+	accounts, err = s.backend.AccountManager().Accounts()
+	require.NoError(err)
 	require.Equal(1, len(accounts), "exactly single account is expected (main account)")
 	require.Equal(string(accounts[0].Hex()), "0x"+address,
 		fmt.Sprintf("main account is not retured as the first key: got %s, expected %s", accounts[0].Hex(), "0x"+address))
@@ -57,7 +52,8 @@ func (s *BackendTestSuite) TestAccountsList() {
 	require.NoError(err, "cannot create sub-account")
 
 	// now we expect to see both main account and sub-account 1
-	accounts = lesService.StatusBackend.AccountManager().Accounts()
+	accounts, err = s.backend.AccountManager().Accounts()
+	require.NoError(err)
 	require.Equal(2, len(accounts), "exactly 2 accounts are expected (main + sub-account 1)")
 	require.Equal(string(accounts[0].Hex()), "0x"+address, "main account is not retured as the first key")
 	require.Equal(string(accounts[1].Hex()), "0x"+subAccount1, "subAcount1 not returned")
@@ -68,7 +64,8 @@ func (s *BackendTestSuite) TestAccountsList() {
 	require.False(subAccount1 == subAccount2 || subPubKey1 == subPubKey2, "sub-account index auto-increament failed")
 
 	// finally, all 3 accounts should show up (main account, sub-accounts 1 and 2)
-	accounts = lesService.StatusBackend.AccountManager().Accounts()
+	accounts, err = s.backend.AccountManager().Accounts()
+	require.NoError(err)
 	require.Equal(3, len(accounts), "unexpected number of accounts")
 	require.Equal(string(accounts[0].Hex()), "0x"+address, "main account is not retured as the first key")
 

geth/api/backend_jail_test.go

@@ -388,7 +388,6 @@ func (s *BackendTestSuite) TestJailWhisper() {
 					throw 'message not sent: ' + JSON.stringify(message);
 				}
 
-
 				var filterName = '` + whisperMessage1 + `';
 				var filterId = filter.filterId;
 				if (!filterId) {
@@ -576,11 +575,13 @@ func (s *BackendTestSuite) TestJailWhisper() {
 
 		jailInstance.Parse(testCaseKey, `
 			var shh = web3.shh;
+			// topic must be 4-byte long
 			var makeTopic = function () {
-				var min = 1;
-				var max = Math.pow(16, 8);
-				var randInt = Math.floor(Math.random() * (max - min + 1)) + min;
-				return web3.toHex(randInt);
+				var topic = '0x';
+				for (var i = 0; i < 8; i++) {
+					topic += Math.floor(Math.random() * 16).toString(16);
+				}
+				return topic;
 			};
 		`)
 

geth/api/backend_test.go

@@ -1,10 +1,12 @@
 package api_test
 
 import (
+	"encoding/json"
 	"math/rand"
 	"testing"
 	"time"
 
+	gethcommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/les"
 	whisper "github.com/ethereum/go-ethereum/whisper/whisperv5"
 	"github.com/status-im/status-go/geth/api"
@@ -256,6 +258,119 @@ func (s *BackendTestSuite) TestCallRPC() {
 	}
 }
 
+func (s *BackendTestSuite) TestCallRPCSendTransaction() {
+	nodeConfig, err := MakeTestNodeConfig(params.RopstenNetworkID)
+	s.NoError(err)
+
+	nodeStarted, err := s.backend.StartNode(nodeConfig)
+	s.NoError(err)
+	defer s.backend.StopNode()
+
+	<-nodeStarted
+
+	// Allow to sync the blockchain.
+	time.Sleep(TestConfig.Node.SyncSeconds * time.Second)
+
+	err = s.backend.AccountManager().SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password)
+	s.NoError(err)
+
+	transactionCompleted := make(chan struct{})
+
+	var txHash gethcommon.Hash
+	node.SetDefaultNodeNotificationHandler(func(rawSignal string) {
+		var signal node.SignalEnvelope
+		err := json.Unmarshal([]byte(rawSignal), &signal)
+		s.NoError(err)
+
+		if signal.Type == node.EventTransactionQueued {
+			event := signal.Event.(map[string]interface{})
+			txID := event["id"].(string)
+			txHash, err = s.backend.CompleteTransaction(common.QueuedTxID(txID), TestConfig.Account1.Password)
+			s.NoError(err, "cannot complete queued transaction %s", txID)
+
+			close(transactionCompleted)
+		}
+	})
+
+	result := s.backend.CallRPC(`{
+		"jsonrpc": "2.0",
+		"id": 1,
+		"method": "eth_sendTransaction",
+		"params": [{
+			"from": "` + TestConfig.Account1.Address + `",
+			"to": "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
+			"value": "0x9184e72a"
+		}]
+	}`)
+	s.NotContains(result, "error")
+
+	select {
+	case <-transactionCompleted:
+	case <-time.After(time.Minute):
+		s.FailNow("sending transaction timed out")
+	}
+
+	s.Equal(`{"jsonrpc":"2.0","id":1,"result":"`+txHash.String()+`"}`, result)
+}
+
+func (s *BackendTestSuite) TestCallRPCSendTransactionUpstream() {
+	nodeConfig, err := MakeTestNodeConfig(params.RopstenNetworkID)
+	s.NoError(err)
+
+	nodeConfig.UpstreamConfig.Enabled = true
+	nodeConfig.UpstreamConfig.URL = "https://ropsten.infura.io/nKmXgiFgc2KqtoQ8BCGJ"
+
+	nodeStarted, err := s.backend.StartNode(nodeConfig)
+	s.NoError(err)
+	defer s.backend.StopNode()
+
+	<-nodeStarted
+
+	// Allow to sync the blockchain.
+	time.Sleep(TestConfig.Node.SyncSeconds * time.Second)
+
+	err = s.backend.AccountManager().SelectAccount(TestConfig.Account2.Address, TestConfig.Account2.Password)
+	s.NoError(err)
+
+	transactionCompleted := make(chan struct{})
+
+	var txHash gethcommon.Hash
+	node.SetDefaultNodeNotificationHandler(func(rawSignal string) {
+		var signal node.SignalEnvelope
+		err := json.Unmarshal([]byte(rawSignal), &signal)
+		s.NoError(err)
+
+		if signal.Type == node.EventTransactionQueued {
+			event := signal.Event.(map[string]interface{})
+			txID := event["id"].(string)
+			txHash, err = s.backend.CompleteTransaction(common.QueuedTxID(txID), TestConfig.Account2.Password)
+			s.NoError(err, "cannot complete queued transaction %s", txID)
+
+			close(transactionCompleted)
+		}
+	})
+
+	result := s.backend.CallRPC(`{
+		"jsonrpc": "2.0",
+		"id": 1,
+		"method": "eth_sendTransaction",
+		"params": [{
+			"from": "` + TestConfig.Account2.Address + `",
+			"to": "` + TestConfig.Account1.Address + `",
+			"value": "0x9184e72a"
+		}]
+	}`)
+	s.NotContains(result, "error")
+
+	select {
+	case <-transactionCompleted:
+	case <-time.After(time.Minute):
+		s.FailNow("sending transaction timed out")
+	}
+
+	s.Equal(`{"jsonrpc":"2.0","id":1,"result":"`+txHash.String()+`"}`, result)
+}
+
 // FIXME(tiabc): There's also a test with the same name in geth/node/manager_test.go
 // so this test should only check StatusBackend logic with a mocked version of the underlying NodeManager.
 func (s *BackendTestSuite) TestRaceConditions() {

geth/common/rpccall.go

@@ -133,3 +133,28 @@ func (r RPCCall) ParseGasPrice() *hexutil.Big {
 
 	return (*hexutil.Big)(parsedValue)
 }
+
+// ToSendTxArgs converts RPCCall to SendTxArgs.
+func (r RPCCall) ToSendTxArgs() SendTxArgs {
+	var err error
+	var fromAddr, toAddr gethcommon.Address
+
+	fromAddr, err = r.ParseFromAddress()
+	if err != nil {
+		fromAddr = gethcommon.HexToAddress("0x0")
+	}
+
+	toAddr, err = r.ParseToAddress()
+	if err != nil {
+		toAddr = gethcommon.HexToAddress("0x0")
+	}
+
+	return SendTxArgs{
+		To:       &toAddr,
+		From:     fromAddr,
+		Value:    r.ParseValue(),
+		Data:     r.ParseData(),
+		Gas:      r.ParseGas(),
+		GasPrice: r.ParseGasPrice(),
+	}
+}

geth/common/types.go

@@ -125,8 +125,11 @@ type AccountManager interface {
 	// Logout clears whisper identities
 	Logout() error
 
-	// AccountsListRequestHandler returns handler to process account list request
-	AccountsListRequestHandler() func(entities []common.Address) []common.Address
+	// Accounts returns handler to process account list request
+	Accounts() ([]common.Address, error)
+
+	// AccountsRPCHandler returns RPC wrapper for Accounts()
+	AccountsRPCHandler() rpc.Handler
 
 	// AddressToDecryptedAccount tries to load decrypted key for a given account.
 	// The running node, has a keystore directory which is loaded on start. Key file
@@ -224,6 +227,8 @@ type TxQueueManager interface {
 	// TODO(adam): might be not needed
 	SetTransactionReturnHandler(fn EnqueuedTxReturnHandler)
 
+	SendTransactionRPCHandler(ctx context.Context, args ...interface{}) (interface{}, error)
+
 	// TransactionReturnHandler returns handler that processes responses from internal tx manager
 	TransactionReturnHandler() func(queuedTx *QueuedTx, err error)