status-im/status-go

package connector

import (
    "context"
    "encoding/json"
    "errors"
    "fmt"

    "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")
)

type API struct {
    s *Service
    r *CommandRegistry
    c *commands.ClientSideHandler
}

func NewAPI(s *Service) *API {
    r := NewCommandRegistry()
    c := commands.NewClientSideHandler()

    // Transactions and signing
    r.Register("eth_sendTransaction", &commands.SendTransactionCommand{
        RpcClient:     s.rpc,
        Db:            s.db,
        ClientHandler: c,
    })
    r.Register("personal_sign", &commands.PersonalSignCommand{
        Db:            s.db,
        ClientHandler: 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,
    }
    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("wallet_switchEthereumChain", &commands.SwitchEthereumChainCommand{
        Db:             s.db,
        NetworkManager: s.nm,
    })

    // Permissions
    r.Register("wallet_requestPermissions", &commands.RequestPermissionsCommand{})
    r.Register("wallet_revokePermissions", &commands.RevokePermissionsCommand{
        Db: s.db,
    })

    return &API{
        s: s,
        r: r,
        c: c,
    }
}

func (api *API) forwardRPC(URL string, request commands.RPCRequest) (interface{}, error) {
    dApp, err := persistence.SelectDAppByUrl(api.s.db, URL)
    if err != nil {
        return "", err
    }

    if dApp == nil {
        return "", commands.ErrDAppIsNotPermittedByUser
    }

    if request.ChainID != dApp.ChainID {
        request.ChainID = dApp.ChainID
    }

    var response map[string]interface{}
    byteRequest, err := json.Marshal(request)
    if err != nil {
        return "", err
    }

    rawResponse := api.s.rpc.CallRaw(string(byteRequest))
    if err := json.Unmarshal([]byte(rawResponse), &response); err != nil {
        return "", err
    }

    if errorField, ok := response["error"]; ok {
        errorMap, _ := errorField.(map[string]interface{})
        errorCode, _ := errorMap["code"].(float64)
        errorMessage, _ := errorMap["message"].(string)
        return nil, fmt.Errorf("error code %v: %s", errorCode, errorMessage)
    }

    if result, ok := response["result"]; ok {
        return result, nil
    }

    return nil, ErrInvalidResponseFromForwardedRpc
}

func (api *API) CallRPC(ctx context.Context, inputJSON string) (interface{}, error) {
    request, err := commands.RPCRequestFromJSON(inputJSON)
    if err != nil {
        return "", err
    }

    if command, exists := api.r.GetCommand(request.Method); exists {
        return command.Execute(ctx, request)
    }

    return api.forwardRPC(request.URL, request)
}

func (api *API) RecallDAppPermission(origin string) error {
    // TODO: close the websocket connection
    return persistence.DeleteDApp(api.s.db, origin)
}

func (api *API) GetPermittedDAppsList() ([]persistence.DApp, error) {
    return persistence.SelectAllDApps(api.s.db)
}

func (api *API) RequestAccountsAccepted(args commands.RequestAccountsAcceptedArgs) error {
    return api.c.RequestAccountsAccepted(args)
}

func (api *API) RequestAccountsRejected(args commands.RejectedArgs) error {
    return api.c.RequestAccountsRejected(args)
}

func (api *API) SendTransactionAccepted(args commands.SendTransactionAcceptedArgs) error {
    return api.c.SendTransactionAccepted(args)
}

func (api *API) SendTransactionRejected(args commands.RejectedArgs) error {
    return api.c.SendTransactionRejected(args)
}

func (api *API) PersonalSignAccepted(args commands.PersonalSignAcceptedArgs) error {
    return api.c.PersonalSignAccepted(args)
}

func (api *API) PersonalSignRejected(args commands.RejectedArgs) error {
    return api.c.PersonalSignRejected(args)
}