feat(connector): changeAccount endpoint (#7053)

* feat(connector)_: change shared address command

fixes #7048

* feat(connector)_: add chainIDSwitched signal

fixes #7048

* feat(connector)_: add factory methods for commands

fixes #7048

* feat(connector)_: reduce coupling

* remove NetworkManager dependency from Commands

fixes #7048

Author: friofry

services/connector/api.go

@@ -5,80 +5,58 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/status-im/status-go/services/connector/chainutils"
 	"github.com/status-im/status-go/services/connector/commands"
 	persistence "github.com/status-im/status-go/services/connector/database"
 )
 
 var (
 	ErrInvalidResponseFromForwardedRpc         = errors.New("invalid response from forwarded RPC")
 	ErrCannotOverrideClientIDForHttpConnection = errors.New("cannot override clientId for HTTP connection")
+	ErrNotAllowedForUntrustedConnection        = errors.New("cannot call from untrusted connection")
 	ErrEmptyClientIDFromTrustedConnection      = errors.New("trusted connection must provide a clientId")
 )
 
 type API struct {
-	s *Service
-	r *CommandRegistry
-	c *commands.ClientSideHandler
+	s                    *Service
+	r                    *CommandRegistry
+	c                    *commands.ClientSideHandler
+	changeAccountCommand *commands.ChangeAccountCommand
 }
 
 func NewAPI(s *Service) *API {
 	r := NewCommandRegistry()
 	c := commands.NewClientSideHandler(s.db)
 
 	// Transactions and signing
-	r.Register("eth_sendTransaction", &commands.SendTransactionCommand{
-		EthClientGetter: s.ethClientGetter,
-		FeeManager:      s.feeManager,
-		Db:              s.db,
-		ClientHandler:   c,
-	})
-	r.Register("personal_sign", &commands.SignCommand{
-		Db:            s.db,
-		ClientHandler: c,
-	})
-	r.Register("eth_signTypedData_v4", &commands.SignCommand{
-		Db:            s.db,
-		ClientHandler: c,
-	})
+	r.Register("eth_sendTransaction", commands.NewSendTransactionCommand(s.db, s.ethClientGetter, s.feeManager, c))
+	r.Register("personal_sign", commands.NewSignCommand(s.db, c))
+	r.Register("eth_signTypedData_v4", commands.NewSignCommand(s.db, c))
 
 	// Accounts query and dapp permissions
 	// NOTE: Some dApps expect same behavior for both eth_accounts and eth_requestAccounts
-	accountsCommand := &commands.RequestAccountsCommand{
-		ClientHandler: c,
-		Db:            s.db,
-	}
+	accountsCommand := commands.NewRequestAccountsCommand(s.db, c)
 	r.Register("eth_accounts", accountsCommand)
 	r.Register("eth_requestAccounts", accountsCommand)
 
 	// Active chain per dapp management
-	r.Register("eth_chainId", &commands.ChainIDCommand{
-		Db:             s.db,
-		NetworkManager: s.nm,
-	})
-	r.Register("net_version", &commands.NetVersionCommand{
-		Db:             s.db,
-		NetworkManager: s.nm,
-	})
-	r.Register("wallet_switchEthereumChain", &commands.SwitchEthereumChainCommand{
-		Db:             s.db,
-		NetworkManager: s.nm,
-	})
+	defaultChainIDGetter := chainutils.NewNetworkManagerAdapter(s.nm)
+	r.Register("eth_chainId", commands.NewChainIDCommand(s.db, defaultChainIDGetter))
+	r.Register("net_version", commands.NewNetVersionCommand(s.db, defaultChainIDGetter))
+	r.Register("wallet_switchEthereumChain", commands.NewSwitchEthereumChainCommand(s.db, s.nm))
 
 	// Permissions
-	r.Register("wallet_requestPermissions", &commands.RequestPermissionsCommand{
-		Db: s.db,
-	})
-	r.Register("wallet_getPermissions", &commands.GetPermissionsCommand{
-		Db: s.db,
-	})
-	r.Register("wallet_revokePermissions", &commands.RevokePermissionsCommand{
-		Db: s.db,
-	})
+	r.Register("wallet_requestPermissions", commands.NewRequestPermissionsCommand(s.db))
+	r.Register("wallet_getPermissions", commands.NewGetPermissionsCommand(s.db))
+	r.Register("wallet_revokePermissions", commands.NewRevokePermissionsCommand(s.db))
+
+	changeAccountCommand := commands.NewChangeAccountCommand(s.db)
 
 	return &API{
-		s: s,
-		r: r,
-		c: c,
+		s:                    s,
+		r:                    r,
+		c:                    c,
+		changeAccountCommand: changeAccountCommand,
 	}
 }
 
@@ -168,3 +146,10 @@ func (api *API) SignAccepted(args commands.SignAcceptedArgs) error {
 func (api *API) SignRejected(args commands.RejectedArgs) error {
 	return api.c.SignRejected(args)
 }
+
+func (api *API) ChangeAccount(ctx context.Context, args commands.ChangeAccountArgs) error {
+	if IsUntrustedConnection(ctx) {
+		return ErrNotAllowedForUntrustedConnection
+	}
+	return api.changeAccountCommand.Execute(args)
+}

services/connector/api_test.go

@@ -96,3 +96,67 @@ func TestCallRPC_TrustedConnectionWithClientID(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, result)
 }
+
+func TestChangeAccount_UntrustedConnection(t *testing.T) {
+	state := setupTests(t)
+
+	// Test untrusted connection (HTTP)
+	ctx := WithConnectionType(context.Background(), ConnectionTypeHTTP)
+
+	args := commands.ChangeAccountArgs{
+		URL:      "https://example.com",
+		ClientID: "test-client",
+	}
+
+	err := state.api.ChangeAccount(ctx, args)
+	require.Error(t, err)
+	require.Equal(t, ErrNotAllowedForUntrustedConnection, err)
+}
+
+func TestCallRPC_MethodNotAllowed(t *testing.T) {
+	state := setupTests(t)
+
+	ctx := WithConnectionType(context.Background(), ConnectionTypeHTTP)
+
+	// Test a method that's not in the allowed list
+	request := `{
+		"method": "eth_subscribe",
+		"params": [],
+		"url": "https://example.com",
+		"name": "Example DApp",
+		"iconUrl": "https://example.com/icon.png"
+	}`
+
+	result, err := state.api.CallRPC(ctx, request)
+	require.Error(t, err)
+	require.Nil(t, result)
+	require.Contains(t, err.Error(), "not allowed")
+}
+
+func TestCallRPC_InvalidJSON(t *testing.T) {
+	state := setupTests(t)
+
+	ctx := WithConnectionType(context.Background(), ConnectionTypeHTTP)
+
+	request := `invalid json`
+
+	result, err := state.api.CallRPC(ctx, request)
+	require.Error(t, err)
+	require.Equal(t, "", result)
+}
+
+func TestRecallDAppPermission_Deprecated(t *testing.T) {
+	state := setupTests(t)
+
+	err := state.api.RecallDAppPermission("https://example.com")
+	// Error is expected when dApp doesn't exist
+	require.Error(t, err)
+}
+
+func TestGetPermittedDAppsList(t *testing.T) {
+	state := setupTests(t)
+
+	dapps, err := state.api.GetPermittedDAppsList()
+	require.NoError(t, err)
+	require.Empty(t, dapps)
+}

services/connector/chainutils/interfaces.go

@@ -18,3 +18,7 @@ type FeeManager interface {
 type EthClientGetter interface {
 	EthClient(chainID uint64) (ethclient.EthClientInterface, error)
 }
+
+type DefaultChainIDGetter interface {
+	GetDefaultChainID() (uint64, error)
+}

services/connector/chainutils/utils.go

@@ -13,6 +13,21 @@ var (
 	ErrUnsupportedNetwork = errors.New("unsupported network")
 )
 
+// Implement DefaultChainIDGetter interface
+type NetworkManagerAdapter struct {
+	networkManager *network.Manager
+}
+
+func NewNetworkManagerAdapter(networkManager *network.Manager) *NetworkManagerAdapter {
+	return &NetworkManagerAdapter{
+		networkManager: networkManager,
+	}
+}
+
+func (a *NetworkManagerAdapter) GetDefaultChainID() (uint64, error) {
+	return GetDefaultChainID(a.networkManager)
+}
+
 // GetSupportedChainIDs retrieves the chain IDs from the provided NetworkManager.
 func GetSupportedChainIDs(networkManager *network.Manager) ([]uint64, error) {
 	activeNetworks, err := networkManager.GetActiveNetworks()

services/connector/commands/accounts.go

@@ -10,7 +10,13 @@ import (
 )
 
 type AccountsCommand struct {
-	Db *sql.DB
+	db *sql.DB
+}
+
+func NewAccountsCommand(db *sql.DB) *AccountsCommand {
+	return &AccountsCommand{
+		db: db,
+	}
 }
 
 func FormatAccountAddressToResponse(address types.Address) []string {
@@ -23,7 +29,7 @@ func (c *AccountsCommand) Execute(ctx context.Context, request RPCRequest) (inte
 		return "", err
 	}
 
-	dApp, err := persistence.SelectDApp(c.Db, request.URL, request.ClientID)
+	dApp, err := persistence.SelectDApp(c.db, request.URL, request.ClientID)
 	if err != nil {
 		return "", err
 	}

services/connector/commands/chain_id.go

@@ -4,15 +4,21 @@ import (
 	"context"
 	"database/sql"
 
-	"github.com/status-im/status-go/rpc/network"
 	"github.com/status-im/status-go/services/connector/chainutils"
 	persistence "github.com/status-im/status-go/services/connector/database"
 	walletCommon "github.com/status-im/status-go/services/wallet/common"
 )
 
 type ChainIDCommand struct {
-	NetworkManager *network.Manager
-	Db             *sql.DB
+	defaultChainIDGetter chainutils.DefaultChainIDGetter
+	db                   *sql.DB
+}
+
+func NewChainIDCommand(db *sql.DB, defaultChainIDGetter chainutils.DefaultChainIDGetter) *ChainIDCommand {
+	return &ChainIDCommand{
+		db:                   db,
+		defaultChainIDGetter: defaultChainIDGetter,
+	}
 }
 
 func (c *ChainIDCommand) Execute(ctx context.Context, request RPCRequest) (interface{}, error) {
@@ -21,14 +27,14 @@ func (c *ChainIDCommand) Execute(ctx context.Context, request RPCRequest) (inter
 		return "", err
 	}
 
-	dApp, err := persistence.SelectDApp(c.Db, request.URL, request.ClientID)
+	dApp, err := persistence.SelectDApp(c.db, request.URL, request.ClientID)
 	if err != nil {
 		return "", err
 	}
 
 	var chainId uint64
 	if dApp == nil {
-		chainId, err = chainutils.GetDefaultChainID(c.NetworkManager)
+		chainId, err = c.defaultChainIDGetter.GetDefaultChainID()
 		if err != nil {
 			return "", err
 		}

services/connector/commands/change_account.go

@@ -0,0 +1,44 @@
+package commands
+
+import (
+	"database/sql"
+
+	persistence "github.com/status-im/status-go/services/connector/database"
+	"github.com/status-im/status-go/signal"
+)
+
+type ChangeAccountCommand struct {
+	db *sql.DB
+}
+
+func NewChangeAccountCommand(db *sql.DB) *ChangeAccountCommand {
+	return &ChangeAccountCommand{
+		db: db,
+	}
+}
+
+func (c *ChangeAccountCommand) Execute(args ChangeAccountArgs) error {
+	err := args.Validate()
+	if err != nil {
+		return err
+	}
+
+	dApp, err := persistence.SelectDApp(c.db, args.URL, args.ClientID)
+	if err != nil {
+		return err
+	}
+
+	if dApp == nil {
+		return nil
+	}
+
+	dApp.SharedAccount = args.Account
+
+	err = persistence.UpsertDApp(c.db, dApp)
+	if err != nil {
+		return err
+	}
+
+	signal.SendConnectorAccountChanged(args.URL, args.ClientID, args.Account)
+	return nil
+}