diff --git a/api/api_ethereum.go b/api/api_ethereum.go
index a4913a6561..bf55a3343b 100644
--- a/api/api_ethereum.go
+++ b/api/api_ethereum.go
@@ -611,7 +611,7 @@ func (api *EthereumAPI) Call(ctx context.Context, args EthTransactionArgs, block
 	if rpcGasCap := bcAPI.RPCGasCap(); rpcGasCap != nil {
 		gasCap = rpcGasCap.Uint64()
 	}
-	result, _, status, err := EthDoCall(ctx, bcAPI, args, blockNrOrHash, overrides, localTxExecutionTime, gasCap)
+	result, _, status, err := EthDoCall(ctx, bcAPI, args, blockNrOrHash, overrides, bcAPI.RPCEVMTimeout(), gasCap)
 	if err != nil {
 		return nil, err
 	}
diff --git a/api/api_public_blockchain.go b/api/api_public_blockchain.go
index afe71843d1..0e47084864 100644
--- a/api/api_public_blockchain.go
+++ b/api/api_public_blockchain.go
@@ -44,8 +44,7 @@ import (
 )
 
 const (
-	defaultGasPrice      = 25 * params.Ston
-	localTxExecutionTime = 5 * time.Second
+	defaultGasPrice = 25 * params.Ston
 )
 
 var logger = log.NewModuleLogger(log.API)
@@ -364,7 +363,7 @@ func (s *PublicBlockChainAPI) Call(ctx context.Context, args CallArgs, blockNrOr
 	if rpcGasCap := s.b.RPCGasCap(); rpcGasCap != nil {
 		gasCap = rpcGasCap
 	}
-	result, _, _, status, err := DoCall(ctx, s.b, args, blockNrOrHash, vm.Config{}, localTxExecutionTime, gasCap)
+	result, _, _, status, err := DoCall(ctx, s.b, args, blockNrOrHash, vm.Config{}, s.b.RPCEVMTimeout(), gasCap)
 	if err != nil {
 		return nil, err
 	}
@@ -381,7 +380,7 @@ func (s *PublicBlockChainAPI) EstimateComputationCost(ctx context.Context, args
 	if rpcGasCap := s.b.RPCGasCap(); rpcGasCap != nil {
 		gasCap = rpcGasCap
 	}
-	_, _, computationCost, _, err := DoCall(ctx, s.b, args, blockNrOrHash, vm.Config{UseOpcodeComputationCost: true}, localTxExecutionTime, gasCap)
+	_, _, computationCost, _, err := DoCall(ctx, s.b, args, blockNrOrHash, vm.Config{UseOpcodeComputationCost: true}, s.b.RPCEVMTimeout(), gasCap)
 	return (hexutil.Uint64)(computationCost), err
 }
 
diff --git a/api/backend.go b/api/backend.go
index 994d31d894..621d896a71 100644
--- a/api/backend.go
+++ b/api/backend.go
@@ -23,6 +23,7 @@ package api
 import (
 	"context"
 	"math/big"
+	"time"
 
 	"github.com/klaytn/klaytn"
 	"github.com/klaytn/klaytn/accounts"
@@ -51,8 +52,9 @@ type Backend interface {
 	ChainDB() database.DBManager
 	EventMux() *event.TypeMux
 	AccountManager() accounts.AccountManager
-	RPCGasCap() *big.Int  // global gas cap for klay_call over rpc: DoS protection
-	RPCTxFeeCap() float64 // global tx fee cap for all transaction related APIs
+	RPCEVMTimeout() time.Duration // global timeout for klay_call
+	RPCGasCap() *big.Int          // global gas cap for klay_call over rpc: DoS protection
+	RPCTxFeeCap() float64         // global tx fee cap for all transaction related APIs
 	Engine() consensus.Engine
 	FeeHistory(ctx context.Context, blockCount int, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error)
 
diff --git a/api/mocks/backend_mock.go b/api/mocks/backend_mock.go
index 3cbe27204a..e109a799a0 100644
--- a/api/mocks/backend_mock.go
+++ b/api/mocks/backend_mock.go
@@ -1,13 +1,14 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: backend.go
+// Source: github.com/klaytn/klaytn/api (interfaces: Backend)
 
-// Package mock_api is a generated GoMock package.
-package mock_api
+// Package api is a generated GoMock package.
+package api
 
 import (
 	context "context"
 	big "math/big"
 	reflect "reflect"
+	time "time"
 
 	gomock "github.com/golang/mock/gomock"
 	klaytn "github.com/klaytn/klaytn"
@@ -62,48 +63,48 @@ func (mr *MockBackendMockRecorder) AccountManager() *gomock.Call {
 }
 
 // BlockByHash mocks base method.
-func (m *MockBackend) BlockByHash(ctx context.Context, blockHash common.Hash) (*types.Block, error) {
+func (m *MockBackend) BlockByHash(arg0 context.Context, arg1 common.Hash) (*types.Block, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BlockByHash", ctx, blockHash)
+	ret := m.ctrl.Call(m, "BlockByHash", arg0, arg1)
 	ret0, _ := ret[0].(*types.Block)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // BlockByHash indicates an expected call of BlockByHash.
-func (mr *MockBackendMockRecorder) BlockByHash(ctx, blockHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) BlockByHash(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockBackend)(nil).BlockByHash), ctx, blockHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockBackend)(nil).BlockByHash), arg0, arg1)
 }
 
 // BlockByNumber mocks base method.
-func (m *MockBackend) BlockByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Block, error) {
+func (m *MockBackend) BlockByNumber(arg0 context.Context, arg1 rpc.BlockNumber) (*types.Block, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BlockByNumber", ctx, blockNr)
+	ret := m.ctrl.Call(m, "BlockByNumber", arg0, arg1)
 	ret0, _ := ret[0].(*types.Block)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // BlockByNumber indicates an expected call of BlockByNumber.
-func (mr *MockBackendMockRecorder) BlockByNumber(ctx, blockNr interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) BlockByNumber(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockBackend)(nil).BlockByNumber), ctx, blockNr)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumber", reflect.TypeOf((*MockBackend)(nil).BlockByNumber), arg0, arg1)
 }
 
 // BlockByNumberOrHash mocks base method.
-func (m *MockBackend) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Block, error) {
+func (m *MockBackend) BlockByNumberOrHash(arg0 context.Context, arg1 rpc.BlockNumberOrHash) (*types.Block, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "BlockByNumberOrHash", ctx, blockNrOrHash)
+	ret := m.ctrl.Call(m, "BlockByNumberOrHash", arg0, arg1)
 	ret0, _ := ret[0].(*types.Block)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // BlockByNumberOrHash indicates an expected call of BlockByNumberOrHash.
-func (mr *MockBackendMockRecorder) BlockByNumberOrHash(ctx, blockNrOrHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) BlockByNumberOrHash(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumberOrHash", reflect.TypeOf((*MockBackend)(nil).BlockByNumberOrHash), ctx, blockNrOrHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByNumberOrHash", reflect.TypeOf((*MockBackend)(nil).BlockByNumberOrHash), arg0, arg1)
 }
 
 // ChainConfig mocks base method.
@@ -177,9 +178,9 @@ func (mr *MockBackendMockRecorder) EventMux() *gomock.Call {
 }
 
 // FeeHistory mocks base method.
-func (m *MockBackend) FeeHistory(ctx context.Context, blockCount int, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {
+func (m *MockBackend) FeeHistory(arg0 context.Context, arg1 int, arg2 rpc.BlockNumber, arg3 []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "FeeHistory", ctx, blockCount, lastBlock, rewardPercentiles)
+	ret := m.ctrl.Call(m, "FeeHistory", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(*big.Int)
 	ret1, _ := ret[1].([][]*big.Int)
 	ret2, _ := ret[2].([]*big.Int)
@@ -189,43 +190,43 @@ func (m *MockBackend) FeeHistory(ctx context.Context, blockCount int, lastBlock
 }
 
 // FeeHistory indicates an expected call of FeeHistory.
-func (mr *MockBackendMockRecorder) FeeHistory(ctx, blockCount, lastBlock, rewardPercentiles interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) FeeHistory(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeeHistory", reflect.TypeOf((*MockBackend)(nil).FeeHistory), ctx, blockCount, lastBlock, rewardPercentiles)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FeeHistory", reflect.TypeOf((*MockBackend)(nil).FeeHistory), arg0, arg1, arg2, arg3)
 }
 
 // GetBlockReceipts mocks base method.
-func (m *MockBackend) GetBlockReceipts(ctx context.Context, blockHash common.Hash) types.Receipts {
+func (m *MockBackend) GetBlockReceipts(arg0 context.Context, arg1 common.Hash) types.Receipts {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetBlockReceipts", ctx, blockHash)
+	ret := m.ctrl.Call(m, "GetBlockReceipts", arg0, arg1)
 	ret0, _ := ret[0].(types.Receipts)
 	return ret0
 }
 
 // GetBlockReceipts indicates an expected call of GetBlockReceipts.
-func (mr *MockBackendMockRecorder) GetBlockReceipts(ctx, blockHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetBlockReceipts(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockReceipts", reflect.TypeOf((*MockBackend)(nil).GetBlockReceipts), ctx, blockHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockReceipts", reflect.TypeOf((*MockBackend)(nil).GetBlockReceipts), arg0, arg1)
 }
 
 // GetBlockReceiptsInCache mocks base method.
-func (m *MockBackend) GetBlockReceiptsInCache(blockHash common.Hash) types.Receipts {
+func (m *MockBackend) GetBlockReceiptsInCache(arg0 common.Hash) types.Receipts {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetBlockReceiptsInCache", blockHash)
+	ret := m.ctrl.Call(m, "GetBlockReceiptsInCache", arg0)
 	ret0, _ := ret[0].(types.Receipts)
 	return ret0
 }
 
 // GetBlockReceiptsInCache indicates an expected call of GetBlockReceiptsInCache.
-func (mr *MockBackendMockRecorder) GetBlockReceiptsInCache(blockHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetBlockReceiptsInCache(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockReceiptsInCache", reflect.TypeOf((*MockBackend)(nil).GetBlockReceiptsInCache), blockHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockReceiptsInCache", reflect.TypeOf((*MockBackend)(nil).GetBlockReceiptsInCache), arg0)
 }
 
 // GetEVM mocks base method.
-func (m *MockBackend) GetEVM(ctx context.Context, msg blockchain.Message, state *state.StateDB, header *types.Header, vmCfg vm.Config) (*vm.EVM, func() error, error) {
+func (m *MockBackend) GetEVM(arg0 context.Context, arg1 blockchain.Message, arg2 *state.StateDB, arg3 *types.Header, arg4 vm.Config) (*vm.EVM, func() error, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetEVM", ctx, msg, state, header, vmCfg)
+	ret := m.ctrl.Call(m, "GetEVM", arg0, arg1, arg2, arg3, arg4)
 	ret0, _ := ret[0].(*vm.EVM)
 	ret1, _ := ret[1].(func() error)
 	ret2, _ := ret[2].(error)
@@ -233,37 +234,37 @@ func (m *MockBackend) GetEVM(ctx context.Context, msg blockchain.Message, state
 }
 
 // GetEVM indicates an expected call of GetEVM.
-func (mr *MockBackendMockRecorder) GetEVM(ctx, msg, state, header, vmCfg interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetEVM(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEVM", reflect.TypeOf((*MockBackend)(nil).GetEVM), ctx, msg, state, header, vmCfg)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEVM", reflect.TypeOf((*MockBackend)(nil).GetEVM), arg0, arg1, arg2, arg3, arg4)
 }
 
 // GetPoolNonce mocks base method.
-func (m *MockBackend) GetPoolNonce(ctx context.Context, addr common.Address) uint64 {
+func (m *MockBackend) GetPoolNonce(arg0 context.Context, arg1 common.Address) uint64 {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetPoolNonce", ctx, addr)
+	ret := m.ctrl.Call(m, "GetPoolNonce", arg0, arg1)
 	ret0, _ := ret[0].(uint64)
 	return ret0
 }
 
 // GetPoolNonce indicates an expected call of GetPoolNonce.
-func (mr *MockBackendMockRecorder) GetPoolNonce(ctx, addr interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetPoolNonce(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPoolNonce", reflect.TypeOf((*MockBackend)(nil).GetPoolNonce), ctx, addr)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPoolNonce", reflect.TypeOf((*MockBackend)(nil).GetPoolNonce), arg0, arg1)
 }
 
 // GetPoolTransaction mocks base method.
-func (m *MockBackend) GetPoolTransaction(txHash common.Hash) *types.Transaction {
+func (m *MockBackend) GetPoolTransaction(arg0 common.Hash) *types.Transaction {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetPoolTransaction", txHash)
+	ret := m.ctrl.Call(m, "GetPoolTransaction", arg0)
 	ret0, _ := ret[0].(*types.Transaction)
 	return ret0
 }
 
 // GetPoolTransaction indicates an expected call of GetPoolTransaction.
-func (mr *MockBackendMockRecorder) GetPoolTransaction(txHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetPoolTransaction(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPoolTransaction", reflect.TypeOf((*MockBackend)(nil).GetPoolTransaction), txHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPoolTransaction", reflect.TypeOf((*MockBackend)(nil).GetPoolTransaction), arg0)
 }
 
 // GetPoolTransactions mocks base method.
@@ -282,23 +283,23 @@ func (mr *MockBackendMockRecorder) GetPoolTransactions() *gomock.Call {
 }
 
 // GetTd mocks base method.
-func (m *MockBackend) GetTd(blockHash common.Hash) *big.Int {
+func (m *MockBackend) GetTd(arg0 common.Hash) *big.Int {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTd", blockHash)
+	ret := m.ctrl.Call(m, "GetTd", arg0)
 	ret0, _ := ret[0].(*big.Int)
 	return ret0
 }
 
 // GetTd indicates an expected call of GetTd.
-func (mr *MockBackendMockRecorder) GetTd(blockHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetTd(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTd", reflect.TypeOf((*MockBackend)(nil).GetTd), blockHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTd", reflect.TypeOf((*MockBackend)(nil).GetTd), arg0)
 }
 
 // GetTxAndLookupInfo mocks base method.
-func (m *MockBackend) GetTxAndLookupInfo(hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64) {
+func (m *MockBackend) GetTxAndLookupInfo(arg0 common.Hash) (*types.Transaction, common.Hash, uint64, uint64) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTxAndLookupInfo", hash)
+	ret := m.ctrl.Call(m, "GetTxAndLookupInfo", arg0)
 	ret0, _ := ret[0].(*types.Transaction)
 	ret1, _ := ret[1].(common.Hash)
 	ret2, _ := ret[2].(uint64)
@@ -307,15 +308,15 @@ func (m *MockBackend) GetTxAndLookupInfo(hash common.Hash) (*types.Transaction,
 }
 
 // GetTxAndLookupInfo indicates an expected call of GetTxAndLookupInfo.
-func (mr *MockBackendMockRecorder) GetTxAndLookupInfo(hash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetTxAndLookupInfo(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxAndLookupInfo", reflect.TypeOf((*MockBackend)(nil).GetTxAndLookupInfo), hash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxAndLookupInfo", reflect.TypeOf((*MockBackend)(nil).GetTxAndLookupInfo), arg0)
 }
 
 // GetTxAndLookupInfoInCache mocks base method.
-func (m *MockBackend) GetTxAndLookupInfoInCache(hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64) {
+func (m *MockBackend) GetTxAndLookupInfoInCache(arg0 common.Hash) (*types.Transaction, common.Hash, uint64, uint64) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTxAndLookupInfoInCache", hash)
+	ret := m.ctrl.Call(m, "GetTxAndLookupInfoInCache", arg0)
 	ret0, _ := ret[0].(*types.Transaction)
 	ret1, _ := ret[1].(common.Hash)
 	ret2, _ := ret[2].(uint64)
@@ -324,15 +325,15 @@ func (m *MockBackend) GetTxAndLookupInfoInCache(hash common.Hash) (*types.Transa
 }
 
 // GetTxAndLookupInfoInCache indicates an expected call of GetTxAndLookupInfoInCache.
-func (mr *MockBackendMockRecorder) GetTxAndLookupInfoInCache(hash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetTxAndLookupInfoInCache(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxAndLookupInfoInCache", reflect.TypeOf((*MockBackend)(nil).GetTxAndLookupInfoInCache), hash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxAndLookupInfoInCache", reflect.TypeOf((*MockBackend)(nil).GetTxAndLookupInfoInCache), arg0)
 }
 
 // GetTxLookupInfoAndReceipt mocks base method.
-func (m *MockBackend) GetTxLookupInfoAndReceipt(ctx context.Context, hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, *types.Receipt) {
+func (m *MockBackend) GetTxLookupInfoAndReceipt(arg0 context.Context, arg1 common.Hash) (*types.Transaction, common.Hash, uint64, uint64, *types.Receipt) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTxLookupInfoAndReceipt", ctx, hash)
+	ret := m.ctrl.Call(m, "GetTxLookupInfoAndReceipt", arg0, arg1)
 	ret0, _ := ret[0].(*types.Transaction)
 	ret1, _ := ret[1].(common.Hash)
 	ret2, _ := ret[2].(uint64)
@@ -342,15 +343,15 @@ func (m *MockBackend) GetTxLookupInfoAndReceipt(ctx context.Context, hash common
 }
 
 // GetTxLookupInfoAndReceipt indicates an expected call of GetTxLookupInfoAndReceipt.
-func (mr *MockBackendMockRecorder) GetTxLookupInfoAndReceipt(ctx, hash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetTxLookupInfoAndReceipt(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxLookupInfoAndReceipt", reflect.TypeOf((*MockBackend)(nil).GetTxLookupInfoAndReceipt), ctx, hash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxLookupInfoAndReceipt", reflect.TypeOf((*MockBackend)(nil).GetTxLookupInfoAndReceipt), arg0, arg1)
 }
 
 // GetTxLookupInfoAndReceiptInCache mocks base method.
-func (m *MockBackend) GetTxLookupInfoAndReceiptInCache(Hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, *types.Receipt) {
+func (m *MockBackend) GetTxLookupInfoAndReceiptInCache(arg0 common.Hash) (*types.Transaction, common.Hash, uint64, uint64, *types.Receipt) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTxLookupInfoAndReceiptInCache", Hash)
+	ret := m.ctrl.Call(m, "GetTxLookupInfoAndReceiptInCache", arg0)
 	ret0, _ := ret[0].(*types.Transaction)
 	ret1, _ := ret[1].(common.Hash)
 	ret2, _ := ret[2].(uint64)
@@ -360,54 +361,54 @@ func (m *MockBackend) GetTxLookupInfoAndReceiptInCache(Hash common.Hash) (*types
 }
 
 // GetTxLookupInfoAndReceiptInCache indicates an expected call of GetTxLookupInfoAndReceiptInCache.
-func (mr *MockBackendMockRecorder) GetTxLookupInfoAndReceiptInCache(Hash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) GetTxLookupInfoAndReceiptInCache(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxLookupInfoAndReceiptInCache", reflect.TypeOf((*MockBackend)(nil).GetTxLookupInfoAndReceiptInCache), Hash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxLookupInfoAndReceiptInCache", reflect.TypeOf((*MockBackend)(nil).GetTxLookupInfoAndReceiptInCache), arg0)
 }
 
 // HeaderByHash mocks base method.
-func (m *MockBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
+func (m *MockBackend) HeaderByHash(arg0 context.Context, arg1 common.Hash) (*types.Header, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HeaderByHash", ctx, hash)
+	ret := m.ctrl.Call(m, "HeaderByHash", arg0, arg1)
 	ret0, _ := ret[0].(*types.Header)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // HeaderByHash indicates an expected call of HeaderByHash.
-func (mr *MockBackendMockRecorder) HeaderByHash(ctx, hash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) HeaderByHash(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockBackend)(nil).HeaderByHash), ctx, hash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockBackend)(nil).HeaderByHash), arg0, arg1)
 }
 
 // HeaderByNumber mocks base method.
-func (m *MockBackend) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error) {
+func (m *MockBackend) HeaderByNumber(arg0 context.Context, arg1 rpc.BlockNumber) (*types.Header, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HeaderByNumber", ctx, blockNr)
+	ret := m.ctrl.Call(m, "HeaderByNumber", arg0, arg1)
 	ret0, _ := ret[0].(*types.Header)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // HeaderByNumber indicates an expected call of HeaderByNumber.
-func (mr *MockBackendMockRecorder) HeaderByNumber(ctx, blockNr interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) HeaderByNumber(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockBackend)(nil).HeaderByNumber), ctx, blockNr)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockBackend)(nil).HeaderByNumber), arg0, arg1)
 }
 
 // HeaderByNumberOrHash mocks base method.
-func (m *MockBackend) HeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Header, error) {
+func (m *MockBackend) HeaderByNumberOrHash(arg0 context.Context, arg1 rpc.BlockNumberOrHash) (*types.Header, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HeaderByNumberOrHash", ctx, blockNrOrHash)
+	ret := m.ctrl.Call(m, "HeaderByNumberOrHash", arg0, arg1)
 	ret0, _ := ret[0].(*types.Header)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // HeaderByNumberOrHash indicates an expected call of HeaderByNumberOrHash.
-func (mr *MockBackendMockRecorder) HeaderByNumberOrHash(ctx, blockNrOrHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) HeaderByNumberOrHash(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumberOrHash", reflect.TypeOf((*MockBackend)(nil).HeaderByNumberOrHash), ctx, blockNrOrHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumberOrHash", reflect.TypeOf((*MockBackend)(nil).HeaderByNumberOrHash), arg0, arg1)
 }
 
 // IsParallelDBWrite mocks base method.
@@ -439,17 +440,17 @@ func (mr *MockBackendMockRecorder) IsSenderTxHashIndexingEnabled() *gomock.Call
 }
 
 // LowerBoundGasPrice mocks base method.
-func (m *MockBackend) LowerBoundGasPrice(ctx context.Context) *big.Int {
+func (m *MockBackend) LowerBoundGasPrice(arg0 context.Context) *big.Int {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LowerBoundGasPrice", ctx)
+	ret := m.ctrl.Call(m, "LowerBoundGasPrice", arg0)
 	ret0, _ := ret[0].(*big.Int)
 	return ret0
 }
 
 // LowerBoundGasPrice indicates an expected call of LowerBoundGasPrice.
-func (mr *MockBackendMockRecorder) LowerBoundGasPrice(ctx interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) LowerBoundGasPrice(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LowerBoundGasPrice", reflect.TypeOf((*MockBackend)(nil).LowerBoundGasPrice), ctx)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LowerBoundGasPrice", reflect.TypeOf((*MockBackend)(nil).LowerBoundGasPrice), arg0)
 }
 
 // Progress mocks base method.
@@ -480,6 +481,20 @@ func (mr *MockBackendMockRecorder) ProtocolVersion() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProtocolVersion", reflect.TypeOf((*MockBackend)(nil).ProtocolVersion))
 }
 
+// RPCEVMTimeout mocks base method.
+func (m *MockBackend) RPCEVMTimeout() time.Duration {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RPCEVMTimeout")
+	ret0, _ := ret[0].(time.Duration)
+	return ret0
+}
+
+// RPCEVMTimeout indicates an expected call of RPCEVMTimeout.
+func (mr *MockBackendMockRecorder) RPCEVMTimeout() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPCEVMTimeout", reflect.TypeOf((*MockBackend)(nil).RPCEVMTimeout))
+}
+
 // RPCGasCap mocks base method.
 func (m *MockBackend) RPCGasCap() *big.Int {
 	m.ctrl.T.Helper()
@@ -509,35 +524,35 @@ func (mr *MockBackendMockRecorder) RPCTxFeeCap() *gomock.Call {
 }
 
 // SendTx mocks base method.
-func (m *MockBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
+func (m *MockBackend) SendTx(arg0 context.Context, arg1 *types.Transaction) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendTx", ctx, signedTx)
+	ret := m.ctrl.Call(m, "SendTx", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // SendTx indicates an expected call of SendTx.
-func (mr *MockBackendMockRecorder) SendTx(ctx, signedTx interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SendTx(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTx", reflect.TypeOf((*MockBackend)(nil).SendTx), ctx, signedTx)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTx", reflect.TypeOf((*MockBackend)(nil).SendTx), arg0, arg1)
 }
 
 // SetHead mocks base method.
-func (m *MockBackend) SetHead(number uint64) {
+func (m *MockBackend) SetHead(arg0 uint64) {
 	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "SetHead", number)
+	m.ctrl.Call(m, "SetHead", arg0)
 }
 
 // SetHead indicates an expected call of SetHead.
-func (mr *MockBackendMockRecorder) SetHead(number interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SetHead(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHead", reflect.TypeOf((*MockBackend)(nil).SetHead), number)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHead", reflect.TypeOf((*MockBackend)(nil).SetHead), arg0)
 }
 
 // StateAndHeaderByNumber mocks base method.
-func (m *MockBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
+func (m *MockBackend) StateAndHeaderByNumber(arg0 context.Context, arg1 rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateAndHeaderByNumber", ctx, number)
+	ret := m.ctrl.Call(m, "StateAndHeaderByNumber", arg0, arg1)
 	ret0, _ := ret[0].(*state.StateDB)
 	ret1, _ := ret[1].(*types.Header)
 	ret2, _ := ret[2].(error)
@@ -545,15 +560,15 @@ func (m *MockBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.Blo
 }
 
 // StateAndHeaderByNumber indicates an expected call of StateAndHeaderByNumber.
-func (mr *MockBackendMockRecorder) StateAndHeaderByNumber(ctx, number interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) StateAndHeaderByNumber(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateAndHeaderByNumber", reflect.TypeOf((*MockBackend)(nil).StateAndHeaderByNumber), ctx, number)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateAndHeaderByNumber", reflect.TypeOf((*MockBackend)(nil).StateAndHeaderByNumber), arg0, arg1)
 }
 
 // StateAndHeaderByNumberOrHash mocks base method.
-func (m *MockBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) {
+func (m *MockBackend) StateAndHeaderByNumberOrHash(arg0 context.Context, arg1 rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StateAndHeaderByNumberOrHash", ctx, blockNrOrHash)
+	ret := m.ctrl.Call(m, "StateAndHeaderByNumberOrHash", arg0, arg1)
 	ret0, _ := ret[0].(*state.StateDB)
 	ret1, _ := ret[1].(*types.Header)
 	ret2, _ := ret[2].(error)
@@ -561,9 +576,9 @@ func (m *MockBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrO
 }
 
 // StateAndHeaderByNumberOrHash indicates an expected call of StateAndHeaderByNumberOrHash.
-func (mr *MockBackendMockRecorder) StateAndHeaderByNumberOrHash(ctx, blockNrOrHash interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) StateAndHeaderByNumberOrHash(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateAndHeaderByNumberOrHash", reflect.TypeOf((*MockBackend)(nil).StateAndHeaderByNumberOrHash), ctx, blockNrOrHash)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateAndHeaderByNumberOrHash", reflect.TypeOf((*MockBackend)(nil).StateAndHeaderByNumberOrHash), arg0, arg1)
 }
 
 // Stats mocks base method.
@@ -582,45 +597,45 @@ func (mr *MockBackendMockRecorder) Stats() *gomock.Call {
 }
 
 // SubscribeChainEvent mocks base method.
-func (m *MockBackend) SubscribeChainEvent(ch chan<- blockchain.ChainEvent) event.Subscription {
+func (m *MockBackend) SubscribeChainEvent(arg0 chan<- blockchain.ChainEvent) event.Subscription {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubscribeChainEvent", ch)
+	ret := m.ctrl.Call(m, "SubscribeChainEvent", arg0)
 	ret0, _ := ret[0].(event.Subscription)
 	return ret0
 }
 
 // SubscribeChainEvent indicates an expected call of SubscribeChainEvent.
-func (mr *MockBackendMockRecorder) SubscribeChainEvent(ch interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SubscribeChainEvent(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainEvent), ch)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainEvent), arg0)
 }
 
 // SubscribeChainHeadEvent mocks base method.
-func (m *MockBackend) SubscribeChainHeadEvent(ch chan<- blockchain.ChainHeadEvent) event.Subscription {
+func (m *MockBackend) SubscribeChainHeadEvent(arg0 chan<- blockchain.ChainHeadEvent) event.Subscription {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubscribeChainHeadEvent", ch)
+	ret := m.ctrl.Call(m, "SubscribeChainHeadEvent", arg0)
 	ret0, _ := ret[0].(event.Subscription)
 	return ret0
 }
 
 // SubscribeChainHeadEvent indicates an expected call of SubscribeChainHeadEvent.
-func (mr *MockBackendMockRecorder) SubscribeChainHeadEvent(ch interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SubscribeChainHeadEvent(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainHeadEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainHeadEvent), ch)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainHeadEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainHeadEvent), arg0)
 }
 
 // SubscribeChainSideEvent mocks base method.
-func (m *MockBackend) SubscribeChainSideEvent(ch chan<- blockchain.ChainSideEvent) event.Subscription {
+func (m *MockBackend) SubscribeChainSideEvent(arg0 chan<- blockchain.ChainSideEvent) event.Subscription {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SubscribeChainSideEvent", ch)
+	ret := m.ctrl.Call(m, "SubscribeChainSideEvent", arg0)
 	ret0, _ := ret[0].(event.Subscription)
 	return ret0
 }
 
 // SubscribeChainSideEvent indicates an expected call of SubscribeChainSideEvent.
-func (mr *MockBackendMockRecorder) SubscribeChainSideEvent(ch interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SubscribeChainSideEvent(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainSideEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainSideEvent), ch)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeChainSideEvent", reflect.TypeOf((*MockBackend)(nil).SubscribeChainSideEvent), arg0)
 }
 
 // SubscribeNewTxsEvent mocks base method.
@@ -638,18 +653,18 @@ func (mr *MockBackendMockRecorder) SubscribeNewTxsEvent(arg0 interface{}) *gomoc
 }
 
 // SuggestPrice mocks base method.
-func (m *MockBackend) SuggestPrice(ctx context.Context) (*big.Int, error) {
+func (m *MockBackend) SuggestPrice(arg0 context.Context) (*big.Int, error) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SuggestPrice", ctx)
+	ret := m.ctrl.Call(m, "SuggestPrice", arg0)
 	ret0, _ := ret[0].(*big.Int)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // SuggestPrice indicates an expected call of SuggestPrice.
-func (mr *MockBackendMockRecorder) SuggestPrice(ctx interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) SuggestPrice(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestPrice", reflect.TypeOf((*MockBackend)(nil).SuggestPrice), ctx)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuggestPrice", reflect.TypeOf((*MockBackend)(nil).SuggestPrice), arg0)
 }
 
 // TxPoolContent mocks base method.
@@ -668,15 +683,15 @@ func (mr *MockBackendMockRecorder) TxPoolContent() *gomock.Call {
 }
 
 // UpperBoundGasPrice mocks base method.
-func (m *MockBackend) UpperBoundGasPrice(ctx context.Context) *big.Int {
+func (m *MockBackend) UpperBoundGasPrice(arg0 context.Context) *big.Int {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UpperBoundGasPrice", ctx)
+	ret := m.ctrl.Call(m, "UpperBoundGasPrice", arg0)
 	ret0, _ := ret[0].(*big.Int)
 	return ret0
 }
 
 // UpperBoundGasPrice indicates an expected call of UpperBoundGasPrice.
-func (mr *MockBackendMockRecorder) UpperBoundGasPrice(ctx interface{}) *gomock.Call {
+func (mr *MockBackendMockRecorder) UpperBoundGasPrice(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpperBoundGasPrice", reflect.TypeOf((*MockBackend)(nil).UpperBoundGasPrice), ctx)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpperBoundGasPrice", reflect.TypeOf((*MockBackend)(nil).UpperBoundGasPrice), arg0)
 }
diff --git a/cmd/utils/config.go b/cmd/utils/config.go
index 90262abace..b4ccf13d90 100644
--- a/cmd/utils/config.go
+++ b/cmd/utils/config.go
@@ -591,7 +591,9 @@ func (kCfg *KlayConfig) SetKlayConfig(ctx *cli.Context, stack *node.Node) {
 	if ctx.GlobalIsSet(RPCGlobalGasCap.Name) {
 		cfg.RPCGasCap = new(big.Int).SetUint64(ctx.GlobalUint64(RPCGlobalGasCap.Name))
 	}
-
+	if ctx.GlobalIsSet(RPCGlobalEVMTimeoutFlag.Name) {
+		cfg.RPCEVMTimeout = ctx.GlobalDuration(RPCGlobalEVMTimeoutFlag.Name)
+	}
 	if ctx.GlobalIsSet(RPCGlobalEthTxFeeCapFlag.Name) {
 		cfg.RPCTxFeeCap = ctx.GlobalFloat64(RPCGlobalEthTxFeeCapFlag.Name)
 	}
diff --git a/cmd/utils/flaggroup.go b/cmd/utils/flaggroup.go
index 74dd2fc6bc..42ffb8f46e 100644
--- a/cmd/utils/flaggroup.go
+++ b/cmd/utils/flaggroup.go
@@ -251,6 +251,7 @@ var FlagGroups = []FlagGroup{
 			RPCVirtualHostsFlag,
 			RPCApiFlag,
 			RPCGlobalGasCap,
+			RPCGlobalEVMTimeoutFlag,
 			RPCGlobalEthTxFeeCapFlag,
 			RPCConcurrencyLimit,
 			RPCNonEthCompatibleFlag,
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
index 2d53540240..72d888a946 100644
--- a/cmd/utils/flags.go
+++ b/cmd/utils/flags.go
@@ -563,6 +563,11 @@ var (
 		Usage:  "Sets a cap on gas that can be used in klay_call/estimateGas",
 		EnvVar: "KLAYTN_RPC_GASCAP",
 	}
+	RPCGlobalEVMTimeoutFlag = cli.DurationFlag{
+		Name:   "rpc.evmtimeout",
+		Usage:  "Sets a timeout used for eth_call (0=infinite)",
+		EnvVar: "KLAYTN_RPC_EVMTIMEOUT",
+	}
 	RPCGlobalEthTxFeeCapFlag = cli.Float64Flag{
 		Name:   "rpc.ethtxfeecap",
 		Usage:  "Sets a cap on transaction fee (in klay) that can be sent via the eth namespace RPC APIs (0 = no cap)",
diff --git a/cmd/utils/nodecmd/nodeflags.go b/cmd/utils/nodecmd/nodeflags.go
index bfc21dec36..e4d2071526 100644
--- a/cmd/utils/nodecmd/nodeflags.go
+++ b/cmd/utils/nodecmd/nodeflags.go
@@ -214,6 +214,7 @@ var CommonRPCFlags = []cli.Flag{
 	altsrc.NewIntFlag(utils.RPCPortFlag),
 	altsrc.NewStringFlag(utils.RPCApiFlag),
 	altsrc.NewUint64Flag(utils.RPCGlobalGasCap),
+	altsrc.NewDurationFlag(utils.RPCGlobalEVMTimeoutFlag),
 	altsrc.NewFloat64Flag(utils.RPCGlobalEthTxFeeCapFlag),
 	altsrc.NewBoolFlag(utils.WSEnabledFlag),
 	altsrc.NewStringFlag(utils.WSListenAddrFlag),
diff --git a/node/cn/api_backend.go b/node/cn/api_backend.go
index 98ceb0c1ef..029efec410 100644
--- a/node/cn/api_backend.go
+++ b/node/cn/api_backend.go
@@ -24,6 +24,7 @@ import (
 	"context"
 	"fmt"
 	"math/big"
+	"time"
 
 	"github.com/klaytn/klaytn"
 	"github.com/klaytn/klaytn/accounts"
@@ -335,6 +336,10 @@ func (b *CNAPIBackend) RPCGasCap() *big.Int {
 	return b.cn.config.RPCGasCap
 }
 
+func (b *CNAPIBackend) RPCEVMTimeout() time.Duration {
+	return b.cn.config.RPCEVMTimeout
+}
+
 func (b *CNAPIBackend) RPCTxFeeCap() float64 {
 	return b.cn.config.RPCTxFeeCap
 }
diff --git a/node/cn/config.go b/node/cn/config.go
index 8e76eaae77..c072b959b5 100644
--- a/node/cn/config.go
+++ b/node/cn/config.go
@@ -64,7 +64,8 @@ func GetDefaultConfig() *Config {
 		},
 		WsEndpoint: "localhost:8546",
 
-		Istanbul: *istanbul.DefaultConfig,
+		Istanbul:      *istanbul.DefaultConfig,
+		RPCEVMTimeout: 5 * time.Second,
 	}
 }
 
@@ -171,6 +172,9 @@ type Config struct {
 	// RPCGasCap is the global gas cap for eth-call variants.
 	RPCGasCap *big.Int `toml:",omitempty"`
 
+	// RPCEVMTimeout is the global timeout for klay/eth-call.
+	RPCEVMTimeout time.Duration
+
 	// RPCTxFeeCap is the global transaction fee(price * gaslimit) cap for
 	// send-transction variants. The unit is klay.
 	// This is used by eth namespace RPC APIs
diff --git a/node/cn/gen_config.go b/node/cn/gen_config.go
index 1704b7fd42..122b396984 100644
--- a/node/cn/gen_config.go
+++ b/node/cn/gen_config.go
@@ -8,7 +8,6 @@ import (
 
 	"github.com/klaytn/klaytn/blockchain"
 	"github.com/klaytn/klaytn/common"
-	"github.com/klaytn/klaytn/common/hexutil"
 	"github.com/klaytn/klaytn/consensus/istanbul"
 	"github.com/klaytn/klaytn/datasync/downloader"
 	"github.com/klaytn/klaytn/node/cn/gasprice"
@@ -16,8 +15,6 @@ import (
 	"github.com/klaytn/klaytn/storage/statedb"
 )
 
-var _ = (*configMarshaling)(nil)
-
 // MarshalTOML marshals as TOML.
 func (c Config) MarshalTOML() (interface{}, error) {
 	type Config struct {
@@ -49,8 +46,10 @@ func (c Config) MarshalTOML() (interface{}, error) {
 		SenderTxHashIndexing    bool
 		ParallelDBWrite         bool
 		TrieNodeCacheConfig     statedb.TrieNodeCacheConfig
+		SnapshotCacheSize       int
+		SnapshotAsyncGen        bool
 		ServiceChainSigner      common.Address `toml:",omitempty"`
-		ExtraData               hexutil.Bytes  `toml:",omitempty"`
+		ExtraData               []byte         `toml:",omitempty"`
 		GasPrice                *big.Int
 		Rewardbase              common.Address `toml:",omitempty"`
 		TxPool                  blockchain.TxPoolConfig
@@ -69,6 +68,8 @@ func (c Config) MarshalTOML() (interface{}, error) {
 		RestartTimeOutFlag      time.Duration
 		DaemonPathFlag          string
 		RPCGasCap               *big.Int `toml:",omitempty"`
+		RPCEVMTimeout           time.Duration
+		RPCTxFeeCap             float64
 	}
 	var enc Config
 	enc.Genesis = c.Genesis
@@ -99,6 +100,8 @@ func (c Config) MarshalTOML() (interface{}, error) {
 	enc.SenderTxHashIndexing = c.SenderTxHashIndexing
 	enc.ParallelDBWrite = c.ParallelDBWrite
 	enc.TrieNodeCacheConfig = c.TrieNodeCacheConfig
+	enc.SnapshotCacheSize = c.SnapshotCacheSize
+	enc.SnapshotAsyncGen = c.SnapshotAsyncGen
 	enc.ServiceChainSigner = c.ServiceChainSigner
 	enc.ExtraData = c.ExtraData
 	enc.GasPrice = c.GasPrice
@@ -119,6 +122,8 @@ func (c Config) MarshalTOML() (interface{}, error) {
 	enc.RestartTimeOutFlag = c.RestartTimeOutFlag
 	enc.DaemonPathFlag = c.DaemonPathFlag
 	enc.RPCGasCap = c.RPCGasCap
+	enc.RPCEVMTimeout = c.RPCEVMTimeout
+	enc.RPCTxFeeCap = c.RPCTxFeeCap
 	return &enc, nil
 }
 
@@ -153,8 +158,10 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 		SenderTxHashIndexing    *bool
 		ParallelDBWrite         *bool
 		TrieNodeCacheConfig     *statedb.TrieNodeCacheConfig
+		SnapshotCacheSize       *int
+		SnapshotAsyncGen        *bool
 		ServiceChainSigner      *common.Address `toml:",omitempty"`
-		ExtraData               *hexutil.Bytes  `toml:",omitempty"`
+		ExtraData               []byte          `toml:",omitempty"`
 		GasPrice                *big.Int
 		Rewardbase              *common.Address `toml:",omitempty"`
 		TxPool                  *blockchain.TxPoolConfig
@@ -173,6 +180,8 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 		RestartTimeOutFlag      *time.Duration
 		DaemonPathFlag          *string
 		RPCGasCap               *big.Int `toml:",omitempty"`
+		RPCEVMTimeout           *time.Duration
+		RPCTxFeeCap             *float64
 	}
 	var dec Config
 	if err := unmarshal(&dec); err != nil {
@@ -262,11 +271,17 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 	if dec.TrieNodeCacheConfig != nil {
 		c.TrieNodeCacheConfig = *dec.TrieNodeCacheConfig
 	}
+	if dec.SnapshotCacheSize != nil {
+		c.SnapshotCacheSize = *dec.SnapshotCacheSize
+	}
+	if dec.SnapshotAsyncGen != nil {
+		c.SnapshotAsyncGen = *dec.SnapshotAsyncGen
+	}
 	if dec.ServiceChainSigner != nil {
 		c.ServiceChainSigner = *dec.ServiceChainSigner
 	}
 	if dec.ExtraData != nil {
-		c.ExtraData = *dec.ExtraData
+		c.ExtraData = dec.ExtraData
 	}
 	if dec.GasPrice != nil {
 		c.GasPrice = dec.GasPrice
@@ -322,5 +337,11 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 	if dec.RPCGasCap != nil {
 		c.RPCGasCap = dec.RPCGasCap
 	}
+	if dec.RPCEVMTimeout != nil {
+		c.RPCEVMTimeout = *dec.RPCEVMTimeout
+	}
+	if dec.RPCTxFeeCap != nil {
+		c.RPCTxFeeCap = *dec.RPCTxFeeCap
+	}
 	return nil
 }