refactor: instantiate RPC server directly (#6846)

* refactor: use rpc server directly instead of running geth node

* refactor: run rpc server in connector service

* fix: force single API instance in connector service

* refactor: move start of time source

* refactor: remove rpc client router blocked methods

* feat: eth service

* fix: remove connector service welcomeServer

* fix: connector allow all origins

* fix: log rpc calls

* fix: use EthClient directly from connector and eth services

* chore: cleanup client and route

* test: set 1 as default ChainID

* test: connector forbidden method

* fix: TestForwardedRPCs

* test: fix rebase issues

* test: Implement ConnectorApiError

* fix: connector api result unmarshal

* fix: TestForwardedRPCs

* chore: address pr comments

* test: fix rebase issues

Author: igor-sirotin

api/backend.go

@@ -47,8 +47,7 @@ type StatusBackend interface {
 	Recover(rpcParams personal.RecoverParams) (types.Address, error)
 	Logout() error
 
-	CallPrivateRPC(inputJSON string) (string, error)
-	CallRPC(inputJSON string) (string, error)
+	CallInProcessRPC(inputJSON string) string
 	HashTransaction(sendArgs wallettypes.SendTxArgs) (wallettypes.SendTxArgs, types.Hash, error)
 	HashTypedData(typed typeddata.TypedData) (types.Hash, error)
 	HashTypedDataV4(typed signercore.TypedData) (types.Hash, error)

api/backend_test.go

@@ -39,7 +39,6 @@ import (
 	"github.com/status-im/status-go/pkg/security"
 	"github.com/status-im/status-go/protocol/requests"
 	"github.com/status-im/status-go/protocol/tt"
-	"github.com/status-im/status-go/rpc"
 	"github.com/status-im/status-go/services/typeddata"
 	"github.com/status-im/status-go/services/wallet"
 	walletservice "github.com/status-im/status-go/services/wallet"
@@ -354,22 +353,20 @@ func TestBackendCallRPCConcurrently(t *testing.T) {
 	for i := 0; i < count; i++ {
 		wg.Add(1)
 		go func(idx int) {
-			result, err := backend.CallRPC(fmt.Sprintf(
-				`{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],"id":%d}`,
+			result := backend.CallInProcessRPC(fmt.Sprintf(
+				`{"jsonrpc":"2.0","method":"appgeneral_version","params":[],"id":%d}`,
 				idx+1,
 			))
-			assert.NoError(t, err)
 			assert.NotContains(t, result, "error")
 			wg.Done()
 		}(i)
 
 		wg.Add(1)
 		go func(idx int) {
-			result, err := backend.CallPrivateRPC(fmt.Sprintf(
-				`{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],"id":%d}`,
+			result := backend.CallInProcessRPC(fmt.Sprintf(
+				`{"jsonrpc":"2.0","method":"appgeneral_version","params":[],"id":%d}`,
 				idx+1,
 			))
-			assert.NoError(t, err)
 			assert.NotContains(t, result, "error")
 			wg.Done()
 		}(i)
@@ -410,62 +407,18 @@ func TestAppStateChange(t *testing.T) {
 	}
 }
 
-func TestBlockedRPCMethods(t *testing.T) {
-	utils.Init()
-
-	backend, stop1, stop2, stopWallet, err := setupGethStatusBackend()
-	defer func() {
-		err := stop1()
-		if err != nil {
-			require.NoError(t, backend.StopNode())
-		}
-	}()
-	defer func() {
-		err := stop2()
-		if err != nil {
-			require.NoError(t, backend.StopNode())
-		}
-	}()
-	defer func() {
-		err := stopWallet()
-		if err != nil {
-			require.NoError(t, backend.StopNode())
-		}
-	}()
-	require.NoError(t, err)
-
-	config, err := utils.MakeTestNodeConfig(params.StatusChainNetworkID)
-	require.NoError(t, err)
-
-	err = backend.StartNode(config)
-	require.NoError(t, err)
-	defer func() { require.NoError(t, backend.StopNode()) }()
-
-	for idx, m := range rpc.BlockedMethods() {
-		result, err := backend.CallRPC(fmt.Sprintf(
-			`{"jsonrpc":"2.0","method":"%s","params":[],"id":%d}`,
-			m,
-			idx+1,
-		))
-		assert.NoError(t, err)
-		assert.Contains(t, result, fmt.Sprintf(`{"code":-32700,"message":"%s"}`, rpc.ErrMethodNotFound))
-	}
-}
-
 func TestCallRPCWithStoppedNode(t *testing.T) {
 	backend := NewGethStatusBackend(tt.MustCreateTestLogger())
 
-	resp, err := backend.CallRPC(
-		`{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],"id":1}`,
+	resp := backend.CallInProcessRPC(
+		`{"jsonrpc":"2.0","method":"appgeneral_version","params":[],"id":1}`,
 	)
-	assert.Equal(t, ErrRPCClientUnavailable, err)
-	assert.Equal(t, "", resp)
+	assert.Contains(t, resp, "error")
 
-	resp, err = backend.CallPrivateRPC(
-		`{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],"id":1}`,
+	resp = backend.CallInProcessRPC(
+		`{"jsonrpc":"2.0","method":"appgeneral_version","params":[],"id":1}`,
 	)
-	assert.Equal(t, ErrRPCClientUnavailable, err)
-	assert.Equal(t, "", resp)
+	assert.Contains(t, resp, "error")
 }
 
 // TODO(adam): add concurrent tests for: SendTransaction

api/geth_backend.go

@@ -71,11 +71,6 @@ import (
 )
 
 var (
-	// ErrUnsupportedRPCMethod is for methods not supported by the RPC interface
-	ErrUnsupportedRPCMethod = errors.New("method is unsupported by RPC interface")
-	// 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")
 	// ErrDBNotAvailable is returned if a method is called before the DB is available for usage
 	ErrDBNotAvailable = errors.New("DB is unavailable")
 )
@@ -1915,13 +1910,6 @@ func (b *GethStatusBackend) GetNodeConfig() (*params.NodeConfig, error) {
 }
 
 func (b *GethStatusBackend) startNode(config *params.NodeConfig) (err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			err = fmt.Errorf("node crashed on start: %v", err)
-			sentry.RecoverError(err)
-		}
-	}()
-
 	b.logger.Info("status-go version details",
 		zap.String("version", version.Version()),
 		zap.String("commit", version.GitCommit()))
@@ -1950,12 +1938,6 @@ func (b *GethStatusBackend) startNode(config *params.NodeConfig) (err error) {
 
 	signal.SendNodeStarted()
 
-	if err = b.registerHandlers(); err != nil {
-		b.logger.Error("Handler registration failed", zap.Error(err))
-		return
-	}
-	b.logger.Info("Handlers registered")
-
 	if b.statusNode.WalletService() != nil {
 		b.statusNode.WalletService().KeycardPairings().SetKeycardPairingsFile(config.KeycardPairingDataFile)
 	}
@@ -2003,21 +1985,8 @@ func (b *GethStatusBackend) RestartNode() error {
 }
 
 // CallRPC executes public RPC requests on node's in-proc RPC server.
-func (b *GethStatusBackend) CallRPC(inputJSON string) (string, error) {
-	client := b.statusNode.RPCClient()
-	if client == nil {
-		return "", ErrRPCClientUnavailable
-	}
-	return client.CallRaw(inputJSON), nil
-}
-
-// CallPrivateRPC executes public and private RPC requests on node's in-proc RPC server.
-func (b *GethStatusBackend) CallPrivateRPC(inputJSON string) (string, error) {
-	client := b.statusNode.RPCClient()
-	if client == nil {
-		return "", ErrRPCClientUnavailable
-	}
-	return client.CallRaw(inputJSON), nil
+func (b *GethStatusBackend) CallInProcessRPC(inputJSON string) string {
+	return b.statusNode.CallInProcessRPC(inputJSON)
 }
 
 // SendTransaction creates a new transaction and waits until it's complete.
@@ -2123,40 +2092,6 @@ func (b *GethStatusBackend) getVerifiedWalletAccount(address, password string) (
 	return b.accountsManager.GetVerifiedWalletAccount(types.HexToAddress(address), password)
 }
 
-// registerHandlers attaches Status callback handlers to running node
-func (b *GethStatusBackend) registerHandlers() error {
-	var clients []*rpc.Client
-
-	if c := b.StatusNode().RPCClient(); c != nil {
-		clients = append(clients, c)
-	} else {
-		return errors.New("RPC client unavailable")
-	}
-
-	for _, client := range clients {
-		client.RegisterHandler(
-			params.AccountsMethodName,
-			func(context.Context, uint64, ...interface{}) (interface{}, error) {
-				return b.accountsManager.Accounts()
-			},
-		)
-
-		if b.allowAllRPC {
-			// this should only happen in unit-tests, this variable is not available outside this package
-			continue
-		}
-		client.RegisterHandler(params.SendTransactionMethodName, unsupportedMethodHandler)
-		client.RegisterHandler(params.PersonalSignMethodName, unsupportedMethodHandler)
-		client.RegisterHandler(params.PersonalRecoverMethodName, unsupportedMethodHandler)
-	}
-
-	return nil
-}
-
-func unsupportedMethodHandler(_ context.Context, _ uint64, _ ...interface{}) (interface{}, error) {
-	return nil, ErrUnsupportedRPCMethod
-}
-
 // ConnectionChange handles network state changes logic.
 func (b *GethStatusBackend) ConnectionChange(typ string, expensive bool) {
 	b.mu.Lock()

mobile/status.go

@@ -313,24 +313,12 @@ func CallRPC(inputJSON string) string {
 
 // callRPC calls public APIs via RPC.
 func callRPC(inputJSON string) string {
-	resp, err := statusBackend.CallRPC(inputJSON)
-	if err != nil {
-		return makeJSONResponse(err)
-	}
-	return resp
+	return callWithResponse(statusBackend.StatusNode().CallInProcessRPC, inputJSON)
 }
 
+// Deprecated: Use CallRPC instead, the behaviour is the same.
 func CallPrivateRPC(inputJSON string) string {
-	return callPrivateRPC(inputJSON)
-}
-
-// callPrivateRPC calls both public and private APIs via RPC.
-func callPrivateRPC(inputJSON string) string {
-	resp, err := statusBackend.CallPrivateRPC(inputJSON)
-	if err != nil {
-		return makeJSONResponse(err)
-	}
-	return resp
+	return callRPC(inputJSON)
 }
 
 func MigrateKeyStoreDirV2(requestJSON string) string {