refactor: RPC server with evmID (ethermint side)

server/start.go

@@ -17,10 +17,12 @@
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net"
 	"net/http"
+	"net/rpc"
 	"os"
 	"path/filepath"
 	"runtime/pprof"
@@ -69,8 +71,14 @@
 	"github.com/evmos/ethermint/server/config"
 	srvflags "github.com/evmos/ethermint/server/flags"
 	ethermint "github.com/evmos/ethermint/types"
+	evmKeeper "github.com/evmos/ethermint/x/evm/keeper"
 )
 
+type IncoApp interface {
+	// Return evm keeper which is used in ethermint side to get evm keeper access
+	GetEvmKeeper() *evmKeeper.Keeper
+}
+
 // DBOpener is a function to open `application.db`, potentially with customized options.
 type DBOpener func(opts types.AppOptions, rootDir string, backend dbm.BackendType) (dbm.DB, error)
 
@@ -488,9 +496,66 @@
 		return err
 	}
 
+	// Start running rpc server for sgx binary access on the evm Keeper statedb
+	listener, err := startRpcServer(svrCtx, g, app)
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		// TODO: Graceful stop
+		listener.Close()
+	}()
+
 	return g.Wait()
 }
 
+func startRpcServer(
+	svrCtx *server.Context,
+	g *errgroup.Group,
+	app types.Application,
+) (listener net.Listener, err error) {
+	ethApp := app.(IncoApp)
+	evmKeeper := ethApp.GetEvmKeeper()
+	if evmKeeper == nil {
+		return nil, errors.New("evm keeper is invalid")
+	}
+
+	g.Go(func() error {
+		listener, err = runRPCServer(svrCtx, evmKeeper)
+		return err
+	})
+
+	return
+}
+
+func runRPCServer(svrCtx *server.Context, keeper *evmKeeper.Keeper) (net.Listener, error) {
+	defer func() {
+		if r := recover(); r != nil {
+			svrCtx.Logger.Error("recovered from panic", "error", r)
+		}
+	}()
+
+	// Run a persistent RPC server for sgx binary can access to evm keeper statedb
+	srv := &evmKeeper.EthmRpcServer{Keeper: keeper}
+	err := rpc.Register(srv)
+	if err != nil {
+		return nil, err
+	}
+
+	rpc.HandleHTTP()
+
+	// TODO handle port customization
+	l, err := net.Listen("tcp", ":9093")
+	if err != nil {
+		return nil, err
+	}
+
+	go http.Serve(l, nil)
+
+	return l, nil
+}
+
 func openDB(_ types.AppOptions, rootDir string, backendType dbm.BackendType) (dbm.DB, error) {
 	dataDir := filepath.Join(rootDir, "data")
 	return dbm.NewDB("application", backendType, dataDir)

x/evm/keeper/keeper.go

@@ -78,6 +78,11 @@
 	// a set of store keys that should cover all the precompile use cases,
 	// or ideally just pass the application's all stores.
 	keys map[string]storetypes.StoreKey
+
+	// sdkCtxs maps a unique evmID to a sdk.Context. It is used to track
+	// requests coming from the SGX binary, and handle them using the correct sdk.Context.
+	// Each evmID is mapped to a unique EVM instance on the TEE side.
+	sdkCtxs map[uint64]*sdk.Context
 }
 
 // NewKeeper generates new evm module keeper
@@ -118,6 +123,7 @@
 		tracer:            tracer,
 		customContractFns: customContractFns,
 		keys:              keys,
+		sdkCtxs:           make(map[uint64]*sdk.Context),
 	}
 }
 
@@ -391,3 +397,7 @@
 	k.SetTransientGasUsed(ctx, result)
 	return result, nil
 }
+
+func (k Keeper) getSdkCtx(evmId uint64) *sdk.Context {
+	return k.sdkCtxs[evmId]
+}

x/evm/keeper/rpc_client.go

@@ -41,8 +41,12 @@
 	return err
 }
 
-func (c *sgxRPCClient) PrepareTx(args PrepareTxArgs, reply *PrepareTxReply) error {
-	return c.doCall("SgxRpcServer.PrepareTx", args, reply)
+func (c *sgxRPCClient) StartEVM(args StartEVMArgs, reply *StartEVMReply) error {
+	return c.doCall("SgxRpcServer.StartEVM", args, reply)
+}
+
+func (c *sgxRPCClient) InitFhevm(args InitFhevmArgs, reply *InitFhevmReply) error {
+	return c.doCall("SgxRpcServer.InitFhevm", args, reply)
 }
 
 func (c *sgxRPCClient) Call(args CallArgs, reply *CallReply) error {
@@ -85,15 +89,19 @@
 	return c.doCall("SgxRpcServer.StateDBGetLogs", args, reply)
 }
 
-// PrepareTxEVMConfig only contains the fields from EVMConfig that are needed
+func (c *sgxRPCClient) StopEVM(args StopEVMArgs, reply *StopEVMReply) error {
+	return c.doCall("SgxRpcServer.StopEVM", args, reply)
+}
+
+// StartEVMTxEVMConfig only contains the fields from EVMConfig that are needed
 // to create a new EVM instance. This is used to pass the EVM configuration
 // over RPC to the SGX binary.
-type PrepareTxEVMConfig struct {
+type StartEVMTxEVMConfig struct {
 	// ChainConfig is the EVM chain configuration in JSON format. Since the
 	// underlying params.ChainConfig struct contains pointer fields, they are
 	// not serializable over RPC with gob. Instead, the JSON representation is
 	// used.
 	ChainConfigJson []byte
 
 	// Fields from EVMConfig
 	CoinBase   common.Address
@@ -111,24 +119,35 @@
 	Overrides string
 }
 
-// PrepareTxArgs is the argument struct for the SgxRpcServer.PrepareTx RPC method.
-type PrepareTxArgs struct {
+// StartEVMArgs is the argument struct for the SgxRpcServer.StartEVM RPC method.
+type StartEVMArgs struct {
 	TxHash []byte
 	// Header is the Tendermint header of the block in which the transaction
 	// will be executed.
 	Header cmtproto.Header
 	// Msg is the EVM transaction message to run on the EVM.
 	Msg core.Message
 	// EvmConfig is the EVM configuration to set.
-	EvmConfig PrepareTxEVMConfig
+	EvmConfig StartEVMTxEVMConfig
+}
+
+// StartEVMReply is the reply struct for the SgxRpcServer.StartEVM RPC method.
+type StartEVMReply struct {
+	EvmId uint64
 }
 
-// PrepareTxArgs is the reply struct for the SgxRpcServer.PrepareTx RPC method.
-type PrepareTxReply struct {
+// InitFhevmArgs is the arg struct for the SgxRpcServer.InitFhevm RPC method.
+type InitFhevmArgs struct {
+	EvmId uint64
+}
+
+// InitFhevmReply is the reply struct for the SgxRpcServer.InitFhevm RPC method.
+type InitFhevmReply struct {
 }
 
 // CallArgs is the argument struct for the SgxRpcServer.Call RPC method.
 type CallArgs struct {
+	EvmId  uint64
 	Caller vm.AccountRef
 	Addr   common.Address
 	Input  []byte
@@ -144,6 +163,7 @@
 
 // CreateArgs is the argument struct for the SgxRpcServer.Create RPC method.
 type CreateArgs struct {
+	EvmId  uint64
 	Caller vm.AccountRef
 	Code   []byte
 	Gas    uint64
@@ -159,72 +179,87 @@
 
 // CommitArgs is the argument struct for the SgxRpcServer.Commit RPC method.
 type CommitArgs struct {
-	Commit bool
+	EvmId uint64
 }
 
 // CommitReply is the reply struct for the SgxRpcServer.Commit RPC method.
 type CommitReply struct {
 }
 
 // CommitArgs is the argument struct for the SgxRpcServer.StateDBSubBalance RPC method.
 type StateDBSubBalanceArgs struct {
+	EvmId  uint64
 	Caller vm.AccountRef
 	Msg    core.Message
 }
 
 // CommitReply is the reply struct for the SgxRpcServer.StateDBSubBalance RPC method.
 type StateDBSubBalanceReply struct {
 }
 
 // CommitArgs is the argument struct for the SgxRpcServer.StateDSetNonce RPC method.
 type StateDBSetNonceArgs struct {
+	EvmId  uint64
 	Caller vm.AccountRef
 	Nonce  uint64
 }
 
 // CommitReply is the reply struct for the SgxRpcServer.StateDSetNonce RPC method.
 type StateDBSetNonceReply struct {
 }
 
 // StateDBAddBalanceArgs is the argument struct for the SgxRpcServer.StateDBAddBalance RPC method.
 type StateDBAddBalanceArgs struct {
+	EvmId       uint64
 	Caller      vm.AccountRef
 	Msg         core.Message
 	LeftoverGas uint64
 }
 
 // StateDBAddBalanceReply is the reply struct for the SgxRpcServer.StateDBAddBalance RPC method.
 type StateDBAddBalanceReply struct {
 }
 
 type StateDBPrepareArgs struct {
-	Msg   core.Message
-	Rules params.Rules
+	EvmId    uint64
+	Msg      core.Message
+	Rules    params.Rules
+	CoinBase common.Address
 }
 
 type StateDBPrepareReply struct {
 }
 
 // StateDBIncreaseNonceArgs is the argument struct for the SgxRpcServer.StateDBIncreaseNonce RPC method.
 type StateDBIncreaseNonceArgs struct {
+	EvmId  uint64
 	Caller vm.AccountRef
 	Msg    core.Message
 }
 
 // StateDBIncreaseNonceReply is the reply struct for the SgxRpcServer.StateDBIncreaseNonce RPC method.
 type StateDBIncreaseNonceReply struct {
 }
 
 type StateDBGetRefundArgs struct {
+	EvmId uint64
 }
 
 type StateDBGetRefundReply struct {
 	Refund uint64
 }
 
 type StateDBGetLogsArgs struct {
+	EvmId uint64
 }
 
 type StateDBGetLogsReply struct {
 	Logs []*ethtypes.Log
 }
+
+type StopEVMArgs struct {
+	EvmId uint64
+}
+
+type StopEVMReply struct {
+}