diff --git a/accounts/abi/bind/backends/blockchain.go b/accounts/abi/bind/backends/blockchain.go
index 60c5cd72d..af1101b18 100644
--- a/accounts/abi/bind/backends/blockchain.go
+++ b/accounts/abi/bind/backends/blockchain.go
@@ -301,7 +301,7 @@ func (b *BlockchainContractBackend) FilterLogs(ctx context.Context, query kaia.F
 	if !ok {
 		return nil, errors.New("BlockChainForCaller is not blockchain.BlockChain")
 	}
-	filter := filters.NewRangeFilter(&filterBackend{state.Database().TrieDB().DiskDB(), bc}, from, to, query.Addresses, query.Topics)
+	filter := filters.NewRangeFilter(&filterBackend{state.Database().TrieDB().DiskDB(), bc, nil}, from, to, query.Addresses, query.Topics)
 
 	logs, err := filter.Logs(ctx)
 	if err != nil {
diff --git a/accounts/abi/bind/backends/blockchain_test.go b/accounts/abi/bind/backends/blockchain_test.go
index 8db5fe905..4afaddba7 100644
--- a/accounts/abi/bind/backends/blockchain_test.go
+++ b/accounts/abi/bind/backends/blockchain_test.go
@@ -383,7 +383,7 @@ func initBackendForFiltererTests(t *testing.T, bc *blockchain.BlockChain) *Block
 	mockBackend.EXPECT().SubscribeRemovedLogsEvent(any).DoAndReturn(subscribeRemovedLogsEvent).AnyTimes()
 	mockBackend.EXPECT().SubscribeChainEvent(any).DoAndReturn(subscribeChainEvent).AnyTimes()
 
-	f := filters.NewEventSystem(&event.TypeMux{}, mockBackend, false)
+	f := filters.NewEventSystem(&event.TypeMux{}, mockBackend)
 	c := NewBlockchainContractBackend(bc, nil, f)
 
 	return c
diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go
index 068446564..679042191 100644
--- a/accounts/abi/bind/backends/simulated.go
+++ b/accounts/abi/bind/backends/simulated.go
@@ -65,9 +65,10 @@ type SimulatedBackend struct {
 	database   database.DBManager     // In memory database to store our testing data
 	blockchain *blockchain.BlockChain // Kaia blockchain to handle the consensus
 
-	mu           sync.Mutex
-	pendingBlock *types.Block   // Currently pending block that will be imported on request
-	pendingState *state.StateDB // Currently pending state that will be the active on request
+	mu              sync.Mutex
+	pendingBlock    *types.Block   // Currently pending block that will be imported on request
+	pendingState    *state.StateDB // Currently pending state that will be the active on request
+	pendingReceipts types.Receipts // Currently receipts for the pending block
 
 	events *filters.EventSystem // Event system for filtering log events live
 
@@ -85,8 +86,8 @@ func NewSimulatedBackendWithDatabase(database database.DBManager, alloc blockcha
 		database:   database,
 		blockchain: blockchain,
 		config:     genesis.Config,
-		events:     filters.NewEventSystem(new(event.TypeMux), &filterBackend{database, blockchain}, false),
 	}
+	backend.events = filters.NewEventSystem(new(event.TypeMux), &filterBackend{database, blockchain, backend})
 	backend.rollback()
 	return backend
 }
@@ -132,11 +133,12 @@ func (b *SimulatedBackend) Rollback() {
 }
 
 func (b *SimulatedBackend) rollback() {
-	blocks, _ := blockchain.GenerateChain(b.config, b.blockchain.CurrentBlock(), gxhash.NewFaker(), b.database, 1, func(int, *blockchain.BlockGen) {})
+	blocks, receipts := blockchain.GenerateChain(b.config, b.blockchain.CurrentBlock(), gxhash.NewFaker(), b.database, 1, func(int, *blockchain.BlockGen) {})
 	stateDB, _ := b.blockchain.State()
 
 	b.pendingBlock = blocks[0]
 	b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil, nil)
+	b.pendingReceipts = receipts[0]
 }
 
 // stateByBlockNumber retrieves a state by a given blocknumber.
@@ -531,7 +533,7 @@ func (b *SimulatedBackend) SendTransaction(_ context.Context, tx *types.Transact
 	}
 
 	// Include tx in chain.
-	blocks, _ := blockchain.GenerateChain(b.config, block, gxhash.NewFaker(), b.database, 1, func(number int, block *blockchain.BlockGen) {
+	blocks, receipts := blockchain.GenerateChain(b.config, block, gxhash.NewFaker(), b.database, 1, func(number int, block *blockchain.BlockGen) {
 		for _, tx := range b.pendingBlock.Transactions() {
 			block.AddTxWithChain(b.blockchain, tx)
 		}
@@ -541,6 +543,7 @@ func (b *SimulatedBackend) SendTransaction(_ context.Context, tx *types.Transact
 
 	b.pendingBlock = blocks[0]
 	b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil, nil)
+	b.pendingReceipts = receipts[0]
 	return nil
 }
 
@@ -559,7 +562,7 @@ func (b *SimulatedBackend) FilterLogs(ctx context.Context, query kaia.FilterQuer
 		to = query.ToBlock.Int64()
 	}
 	// Construct and execute the filter
-	filter := filters.NewRangeFilter(&filterBackend{b.database, b.blockchain}, from, to, query.Addresses, query.Topics)
+	filter := filters.NewRangeFilter(&filterBackend{b.database, b.blockchain, b}, from, to, query.Addresses, query.Topics)
 
 	// Run the filter and return all the logs
 	logs, err := filter.Logs(ctx)
@@ -654,13 +657,14 @@ func (b *SimulatedBackend) AdjustTime(adjustment time.Duration) error {
 		return errors.New("Could not adjust time on non-empty block")
 	}
 
-	blocks, _ := blockchain.GenerateChain(b.config, b.blockchain.CurrentBlock(), gxhash.NewFaker(), b.database, 1, func(number int, block *blockchain.BlockGen) {
+	blocks, receipts := blockchain.GenerateChain(b.config, b.blockchain.CurrentBlock(), gxhash.NewFaker(), b.database, 1, func(number int, block *blockchain.BlockGen) {
 		block.OffsetTime(int64(adjustment.Seconds()))
 	})
 	stateDB, _ := b.blockchain.State()
 
 	b.pendingBlock = blocks[0]
 	b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil, nil)
+	b.pendingReceipts = receipts[0]
 
 	return nil
 }
@@ -677,8 +681,9 @@ func (b *SimulatedBackend) PendingBlock() *types.Block {
 // filterBackend implements filters.Backend to support filtering for logs without
 // taking bloom-bits acceleration structures into account.
 type filterBackend struct {
-	db database.DBManager
-	bc *blockchain.BlockChain
+	db      database.DBManager
+	bc      *blockchain.BlockChain
+	backend *SimulatedBackend
 }
 
 func (fb *filterBackend) ChainDB() database.DBManager { return fb.db }
@@ -695,6 +700,10 @@ func (fb *filterBackend) HeaderByNumber(_ context.Context, block rpc.BlockNumber
 	return fb.bc.GetHeaderByNumber(uint64(block.Int64())), nil
 }
 
+func (fb *filterBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) {
+	return fb.backend.pendingBlock, fb.backend.pendingReceipts, fb.backend.pendingState.Copy()
+}
+
 func (fb *filterBackend) GetBlockReceipts(_ context.Context, hash common.Hash) types.Receipts {
 	return fb.bc.GetReceiptsByBlockHash(hash)
 }
diff --git a/api/api_ethereum.go b/api/api_ethereum.go
index 7a11107d7..c6d641e05 100644
--- a/api/api_ethereum.go
+++ b/api/api_ethereum.go
@@ -707,14 +707,12 @@ func (api *EthereumAPI) EstimateGas(ctx context.Context, args EthTransactionArgs
 
 // GetBlockTransactionCountByNumber returns the number of transactions in the block with the given block number.
 func (api *EthereumAPI) GetBlockTransactionCountByNumber(ctx context.Context, blockNr rpc.BlockNumber) *hexutil.Uint {
-	transactionCount, _ := api.publicTransactionPoolAPI.GetBlockTransactionCountByNumber(ctx, blockNr)
-	return transactionCount
+	return api.publicTransactionPoolAPI.GetBlockTransactionCountByNumber(ctx, blockNr)
 }
 
 // GetBlockTransactionCountByHash returns the number of transactions in the block with the given hash.
 func (api *EthereumAPI) GetBlockTransactionCountByHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint {
-	transactionCount, _ := api.publicTransactionPoolAPI.GetBlockTransactionCountByHash(ctx, blockHash)
-	return transactionCount
+	return api.publicTransactionPoolAPI.GetBlockTransactionCountByHash(ctx, blockHash)
 }
 
 // EthRPCTransaction represents a transaction that will serialize to the RPC representation of a transaction
@@ -968,8 +966,8 @@ func (api *EthereumAPI) GetTransactionByBlockHashAndIndex(ctx context.Context, b
 
 // GetRawTransactionByBlockNumberAndIndex returns the bytes of the transaction for the given block number and index.
 func (api *EthereumAPI) GetRawTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) hexutil.Bytes {
-	rawTx, err := api.publicTransactionPoolAPI.GetRawTransactionByBlockNumberAndIndex(ctx, blockNr, index)
-	if rawTx == nil || err != nil {
+	rawTx := api.publicTransactionPoolAPI.GetRawTransactionByBlockNumberAndIndex(ctx, blockNr, index)
+	if rawTx == nil {
 		return nil
 	}
 	if rawTx[0] == byte(types.EthereumTxTypeEnvelope) {
@@ -980,8 +978,8 @@ func (api *EthereumAPI) GetRawTransactionByBlockNumberAndIndex(ctx context.Conte
 
 // GetRawTransactionByBlockHashAndIndex returns the bytes of the transaction for the given block hash and index.
 func (api *EthereumAPI) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) hexutil.Bytes {
-	rawTx, err := api.publicTransactionPoolAPI.GetRawTransactionByBlockHashAndIndex(ctx, blockHash, index)
-	if rawTx == nil || err != nil {
+	rawTx := api.publicTransactionPoolAPI.GetRawTransactionByBlockHashAndIndex(ctx, blockHash, index)
+	if rawTx == nil {
 		return nil
 	}
 	if rawTx[0] == byte(types.EthereumTxTypeEnvelope) {
diff --git a/api/api_public_klay.go b/api/api_public_klay.go
index 5741dde93..bc8f4f047 100644
--- a/api/api_public_klay.go
+++ b/api/api_public_klay.go
@@ -78,7 +78,7 @@ type FeeHistoryResult struct {
 
 // FeeHistory returns data relevant for fee estimation based on the specified range of blocks.
 func (s *PublicKaiaAPI) FeeHistory(ctx context.Context, blockCount DecimalOrHex, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*FeeHistoryResult, error) {
-	oldest, reward, baseFee, gasUsed, err := s.b.FeeHistory(ctx, int(blockCount), lastBlock, rewardPercentiles)
+	oldest, reward, baseFee, gasUsed, err := s.b.FeeHistory(ctx, uint64(blockCount), lastBlock, rewardPercentiles)
 	if err != nil {
 		return nil, err
 	}
diff --git a/api/api_public_transaction_pool.go b/api/api_public_transaction_pool.go
index 560b19179..47e79ad01 100644
--- a/api/api_public_transaction_pool.go
+++ b/api/api_public_transaction_pool.go
@@ -51,59 +51,56 @@ func NewPublicTransactionPoolAPI(b Backend, nonceLock *AddrLocker) *PublicTransa
 }
 
 // GetBlockTransactionCountByNumber returns the number of transactions in the block with the given block number.
-func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*hexutil.Uint, error) {
-	block, err := s.b.BlockByNumber(ctx, blockNr)
-	if block != nil && err == nil {
+func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByNumber(ctx context.Context, blockNr rpc.BlockNumber) *hexutil.Uint {
+	block, _ := s.b.BlockByNumber(ctx, blockNr)
+	if block != nil {
 		n := hexutil.Uint(len(block.Transactions()))
-		return &n, err
+		return &n
 	}
-	return nil, err
+	return nil
 }
 
 // GetBlockTransactionCountByHash returns the number of transactions in the block with the given hash.
-func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByHash(ctx context.Context, blockHash common.Hash) (*hexutil.Uint, error) {
-	block, err := s.b.BlockByHash(ctx, blockHash)
-	if block != nil && err == nil {
+func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint {
+	block, _ := s.b.BlockByHash(ctx, blockHash)
+	if block != nil {
 		n := hexutil.Uint(len(block.Transactions()))
-		return &n, err
+		return &n
 	}
-	return nil, err
+	return nil
 }
 
 // GetTransactionByBlockNumberAndIndex returns the transaction for the given block number and index.
-func (s *PublicTransactionPoolAPI) GetTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) (map[string]interface{}, error) {
-	block, err := s.b.BlockByNumber(ctx, blockNr)
-	if block != nil && err == nil {
-		return newRPCTransactionFromBlockIndex(block, uint64(index), s.b.ChainConfig()), nil
+func (s *PublicTransactionPoolAPI) GetTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) map[string]interface{} {
+	block, _ := s.b.BlockByNumber(ctx, blockNr)
+	if block != nil {
+		return newRPCTransactionFromBlockIndex(block, uint64(index), s.b.ChainConfig())
 	}
-	return nil, err
+	return nil
 }
 
 // GetTransactionByBlockHashAndIndex returns the transaction for the given block hash and index.
-func (s *PublicTransactionPoolAPI) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) (map[string]interface{}, error) {
-	block, err := s.b.BlockByHash(ctx, blockHash)
-	if block != nil && err == nil {
-		return newRPCTransactionFromBlockIndex(block, uint64(index), s.b.ChainConfig()), nil
+func (s *PublicTransactionPoolAPI) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) map[string]interface{} {
+	if block, _ := s.b.BlockByHash(ctx, blockHash); block != nil {
+		return newRPCTransactionFromBlockIndex(block, uint64(index), s.b.ChainConfig())
 	}
-	return nil, err
+	return nil
 }
 
 // GetRawTransactionByBlockNumberAndIndex returns the bytes of the transaction for the given block number and index.
-func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) (hexutil.Bytes, error) {
-	block, err := s.b.BlockByNumber(ctx, blockNr)
-	if block != nil && err == nil {
-		return newRPCRawTransactionFromBlockIndex(block, uint64(index)), nil
+func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) hexutil.Bytes {
+	if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil {
+		return newRPCRawTransactionFromBlockIndex(block, uint64(index))
 	}
-	return nil, err
+	return nil
 }
 
 // GetRawTransactionByBlockHashAndIndex returns the bytes of the transaction for the given block hash and index.
-func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) (hexutil.Bytes, error) {
-	block, err := s.b.BlockByHash(ctx, blockHash)
-	if block != nil && err == nil {
-		return newRPCRawTransactionFromBlockIndex(block, uint64(index)), nil
+func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) hexutil.Bytes {
+	if block, _ := s.b.BlockByHash(ctx, blockHash); block != nil {
+		return newRPCRawTransactionFromBlockIndex(block, uint64(index))
 	}
-	return nil, err
+	return nil
 }
 
 // GetTransactionCount returns the number of transactions the given address has sent for the given block number or hash
@@ -576,18 +573,12 @@ func (s *PublicTransactionPoolAPI) RecoverFromTransaction(ctx context.Context, e
 		return common.Address{}, err
 	}
 
-	var bn uint64
-	if blockNumber == rpc.LatestBlockNumber || blockNumber == rpc.PendingBlockNumber {
-		bn = s.b.CurrentBlock().NumberU64()
-	} else {
-		bn = blockNumber.Uint64()
-	}
-
-	signer := types.MakeSigner(s.b.ChainConfig(), new(big.Int).SetUint64(bn))
-	state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNumber)
+	state, header, err := s.b.StateAndHeaderByNumber(ctx, blockNumber)
 	if err != nil {
 		return common.Address{}, err
 	}
+	bn := header.Number.Uint64()
+	signer := types.MakeSigner(s.b.ChainConfig(), new(big.Int).SetUint64(bn))
 	_, err = tx.ValidateSender(signer, state, bn)
 	if err != nil {
 		return common.Address{}, err
diff --git a/api/backend.go b/api/backend.go
index 438f209df..9c1cf2f6e 100644
--- a/api/backend.go
+++ b/api/backend.go
@@ -60,7 +60,7 @@ type Backend interface {
 	RPCGasCap() *big.Int          // global gas cap for eth/kaia_call/estimateGas/estimateComputationCost
 	RPCTxFeeCap() float64         // global tx fee cap in eth_signTransaction
 	Engine() consensus.Engine
-	FeeHistory(ctx context.Context, blockCount int, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error)
+	FeeHistory(ctx context.Context, blockCount uint64, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error)
 
 	// BlockChain API
 	SetHead(number uint64) error
@@ -72,6 +72,7 @@ type Backend interface {
 	BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Block, error)
 	StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error)
 	StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error)
+	Pending() (*types.Block, types.Receipts, *state.StateDB)
 	GetBlockReceipts(ctx context.Context, blockHash common.Hash) types.Receipts
 	GetTxLookupInfoAndReceipt(ctx context.Context, hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64, *types.Receipt)
 	GetTxAndLookupInfo(hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64)
diff --git a/api/mocks/backend_mock.go b/api/mocks/backend_mock.go
index 5a6c626ff..c90ecf1c4 100644
--- a/api/mocks/backend_mock.go
+++ b/api/mocks/backend_mock.go
@@ -178,7 +178,7 @@ func (mr *MockBackendMockRecorder) EventMux() *gomock.Call {
 }
 
 // FeeHistory mocks base method.
-func (m *MockBackend) FeeHistory(arg0 context.Context, arg1 int, arg2 rpc.BlockNumber, arg3 []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {
+func (m *MockBackend) FeeHistory(arg0 context.Context, arg1 uint64, arg2 rpc.BlockNumber, arg3 []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "FeeHistory", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(*big.Int)
@@ -453,6 +453,22 @@ func (mr *MockBackendMockRecorder) LowerBoundGasPrice(arg0 interface{}) *gomock.
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LowerBoundGasPrice", reflect.TypeOf((*MockBackend)(nil).LowerBoundGasPrice), arg0)
 }
 
+// Pending mocks base method.
+func (m *MockBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Pending")
+	ret0, _ := ret[0].(*types.Block)
+	ret1, _ := ret[1].(types.Receipts)
+	ret2, _ := ret[2].(*state.StateDB)
+	return ret0, ret1, ret2
+}
+
+// Pending indicates an expected call of Pending.
+func (mr *MockBackendMockRecorder) Pending() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pending", reflect.TypeOf((*MockBackend)(nil).Pending))
+}
+
 // Progress mocks base method.
 func (m *MockBackend) Progress() kaia.SyncProgress {
 	m.ctrl.T.Helper()
diff --git a/node/cn/api.go b/node/cn/api.go
index 15de359cb..601cfe665 100644
--- a/node/cn/api.go
+++ b/node/cn/api.go
@@ -291,7 +291,7 @@ func (api *PublicDebugAPI) DumpBlock(ctx context.Context, blockNrOrHash rpc.Bloc
 		// If we're dumping the pending state, we need to request
 		// both the pending block as well as the pending state from
 		// the miner and operate on those
-		_, stateDb := api.cn.miner.Pending()
+		_, _, stateDb := api.cn.miner.Pending()
 		if stateDb == nil {
 			return state.Dump{}, fmt.Errorf("pending block is not prepared yet")
 		}
diff --git a/node/cn/api_backend.go b/node/cn/api_backend.go
index 4beb8a1a6..c4c4db464 100644
--- a/node/cn/api_backend.go
+++ b/node/cn/api_backend.go
@@ -172,10 +172,14 @@ func (b *CNAPIBackend) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rp
 	return nil, fmt.Errorf("invalid arguments; neither block nor hash specified")
 }
 
+func (b *CNAPIBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) {
+	return b.cn.miner.Pending()
+}
+
 func (b *CNAPIBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
 	// Pending state is only known by the miner
 	if blockNr == rpc.PendingBlockNumber {
-		block, state := b.cn.miner.Pending()
+		block, _, state := b.cn.miner.Pending()
 		if block == nil || state == nil {
 			return nil, nil, fmt.Errorf("pending block is not prepared yet")
 		}
@@ -393,6 +397,6 @@ func (b *CNAPIBackend) StateAtTransaction(ctx context.Context, block *types.Bloc
 	return b.cn.stateAtTransaction(block, txIndex, reexec, base, readOnly, preferDisk)
 }
 
-func (b *CNAPIBackend) FeeHistory(ctx context.Context, blockCount int, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {
+func (b *CNAPIBackend) FeeHistory(ctx context.Context, blockCount uint64, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {
 	return b.gpo.FeeHistory(ctx, blockCount, lastBlock, rewardPercentiles)
 }
diff --git a/node/cn/api_backend_test.go b/node/cn/api_backend_test.go
index 6fa15b3cf..aae3d1c91 100644
--- a/node/cn/api_backend_test.go
+++ b/node/cn/api_backend_test.go
@@ -425,6 +425,7 @@ func TestCNAPIBackend_BlockByNumberOrHash(t *testing.T) {
 func TestCNAPIBackend_StateAndHeaderByNumber(t *testing.T) {
 	blockNum := uint64(123)
 	block := newBlock(int(blockNum))
+	var reciept types.Receipts
 
 	stateDB, err := state.New(common.Hash{}, state.NewDatabase(database.NewMemoryDBManager()), nil, nil)
 	if err != nil {
@@ -436,7 +437,7 @@ func TestCNAPIBackend_StateAndHeaderByNumber(t *testing.T) {
 	expectedHeader := block.Header()
 	{
 		mockCtrl, _, mockMiner, api := newCNAPIBackend(t)
-		mockMiner.EXPECT().Pending().Return(block, stateDB).Times(1)
+		mockMiner.EXPECT().Pending().Return(block, reciept, stateDB).Times(1)
 
 		returnedStateDB, header, err := api.StateAndHeaderByNumber(context.Background(), rpc.PendingBlockNumber)
 
diff --git a/node/cn/backend.go b/node/cn/backend.go
index d440f4616..c66428577 100644
--- a/node/cn/backend.go
+++ b/node/cn/backend.go
@@ -85,7 +85,7 @@ type Miner interface {
 	Mining() bool
 	HashRate() (tot int64)
 	SetExtra(extra []byte) error
-	Pending() (*types.Block, *state.StateDB)
+	Pending() (*types.Block, types.Receipts, *state.StateDB)
 	PendingBlock() *types.Block
 	kaiax.ExecutionModuleHost // Because miner executes blocks, inject ExecutionModule.
 }
@@ -670,7 +670,7 @@ func (s *CN) APIs() []rpc.API {
 	// Append any APIs exposed explicitly by the consensus engine
 	apis = append(apis, s.engine.APIs(s.BlockChain())...)
 
-	publicFilterAPI := filters.NewPublicFilterAPI(s.APIBackend, false)
+	publicFilterAPI := filters.NewPublicFilterAPI(s.APIBackend)
 	publicDownloaderAPI := downloader.NewPublicDownloaderAPI(s.protocolManager.Downloader(), s.eventMux)
 	privateDownloaderAPI := downloader.NewPrivateDownloaderAPI(s.protocolManager.Downloader())
 
diff --git a/node/cn/filters/api.go b/node/cn/filters/api.go
index 9267f3b65..4f99d458d 100644
--- a/node/cn/filters/api.go
+++ b/node/cn/filters/api.go
@@ -49,6 +49,8 @@ var (
 	GetLogsMaxItems       = int(10000)       // maximum allowed number of return items for getLogs and getFilterLogs APIs
 )
 
+var errPendingLogsUnsupported = errors.New("pending logs are not supported")
+
 // filter is a helper struct that holds meta information over the filter type
 // and associated subscription in the event system.
 type filter struct {
@@ -76,12 +78,12 @@ type PublicFilterAPI struct {
 }
 
 // NewPublicFilterAPI returns a new PublicFilterAPI instance.
-func NewPublicFilterAPI(backend Backend, lightMode bool) *PublicFilterAPI {
+func NewPublicFilterAPI(backend Backend) *PublicFilterAPI {
 	api := &PublicFilterAPI{
 		backend: backend,
 		mux:     backend.EventMux(),
 		chainDB: backend.ChainDB(),
-		events:  NewEventSystem(backend.EventMux(), backend, lightMode),
+		events:  NewEventSystem(backend.EventMux(), backend),
 		filters: make(map[rpc.ID]*filter),
 		timeout: defaultFilterDeadline,
 	}
diff --git a/node/cn/filters/filter.go b/node/cn/filters/filter.go
index 33419d3f4..8635b9395 100644
--- a/node/cn/filters/filter.go
+++ b/node/cn/filters/filter.go
@@ -31,6 +31,7 @@ import (
 
 	"github.com/kaiachain/kaia/blockchain"
 	"github.com/kaiachain/kaia/blockchain/bloombits"
+	"github.com/kaiachain/kaia/blockchain/state"
 	"github.com/kaiachain/kaia/blockchain/types"
 	"github.com/kaiachain/kaia/common"
 	"github.com/kaiachain/kaia/event"
@@ -45,6 +46,7 @@ type Backend interface {
 	EventMux() *event.TypeMux
 	HeaderByHash(ctx context.Context, blockHash common.Hash) (*types.Header, error)
 	HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error)
+	Pending() (*types.Block, types.Receipts, *state.StateDB)
 	GetBlockReceipts(ctx context.Context, blockHash common.Hash) types.Receipts
 	GetLogs(ctx context.Context, blockHash common.Hash) ([][]*types.Log, error)
 
@@ -139,18 +141,23 @@ func (f *Filter) Logs(ctx context.Context) ([]*types.Log, error) {
 		return f.blockLogs(ctx, header)
 	}
 
+	// Disallow pending logs.
+	if f.begin == rpc.PendingBlockNumber.Int64() || f.end == rpc.PendingBlockNumber.Int64() {
+		return nil, errPendingLogsUnsupported
+	}
+
 	// Figure out the limits of the filter range
 	header, _ := f.backend.HeaderByNumber(ctx, rpc.LatestBlockNumber)
 	if header == nil {
-		return nil, nil
+		return nil, errors.New("latest header not found")
 	}
 	head := header.Number.Uint64()
 
-	if f.begin == -1 {
+	if f.begin == rpc.LatestBlockNumber.Int64() {
 		f.begin = int64(head)
 	}
 	end := uint64(f.end)
-	if f.end == -1 {
+	if f.end == rpc.LatestBlockNumber.Int64() {
 		end = head
 	}
 	// Gather all indexed logs, and finish with non indexed ones
diff --git a/node/cn/filters/filter_system.go b/node/cn/filters/filter_system.go
index 659e92b9a..0590974a9 100644
--- a/node/cn/filters/filter_system.go
+++ b/node/cn/filters/filter_system.go
@@ -23,7 +23,6 @@
 package filters
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"sync"
@@ -47,10 +46,6 @@ const (
 	UnknownSubscription Type = iota
 	// LogsSubscription queries for new or removed (chain reorg) logs
 	LogsSubscription
-	// PendingLogsSubscription queries for logs in pending blocks
-	PendingLogsSubscription
-	// MinedAndPendingLogsSubscription queries for logs in mined and pending blocks.
-	MinedAndPendingLogsSubscription
 	// PendingTransactionsSubscription queries tx hashes for pending
 	// transactions entering the pending state
 	PendingTransactionsSubscription
@@ -93,17 +88,14 @@ type subscription struct {
 // EventSystem creates subscriptions, processes events and broadcasts them to the
 // subscription which match the subscription criteria.
 type EventSystem struct {
-	mux       *event.TypeMux
-	backend   Backend
-	lightMode bool
-	lastHead  *types.Header
+	mux     *event.TypeMux
+	backend Backend
 
 	// Subscriptions
-	txsSub        event.Subscription         // Subscription for new transaction event
-	logsSub       event.Subscription         // Subscription for new log event
-	rmLogsSub     event.Subscription         // Subscription for removed log event
-	chainSub      event.Subscription         // Subscription for new chain event
-	pendingLogSub *event.TypeMuxSubscription // Subscription for pending log event
+	txsSub    event.Subscription // Subscription for new transaction event
+	logsSub   event.Subscription // Subscription for new log event
+	rmLogsSub event.Subscription // Subscription for removed log event
+	chainSub  event.Subscription // Subscription for new chain event
 
 	// Channels
 	install   chan *subscription               // install filter for event notification
@@ -120,11 +112,10 @@ type EventSystem struct {
 //
 // The returned manager has a loop that needs to be stopped with the Stop function
 // or by stopping the given mux.
-func NewEventSystem(mux *event.TypeMux, backend Backend, lightMode bool) *EventSystem {
+func NewEventSystem(mux *event.TypeMux, backend Backend) *EventSystem {
 	m := &EventSystem{
 		mux:       mux,
 		backend:   backend,
-		lightMode: lightMode,
 		install:   make(chan *subscription),
 		uninstall: make(chan *subscription),
 		txsCh:     make(chan blockchain.NewTxsEvent, txChanSize),
@@ -138,12 +129,9 @@ func NewEventSystem(mux *event.TypeMux, backend Backend, lightMode bool) *EventS
 	m.logsSub = m.backend.SubscribeLogsEvent(m.logsCh)
 	m.rmLogsSub = m.backend.SubscribeRemovedLogsEvent(m.rmLogsCh)
 	m.chainSub = m.backend.SubscribeChainEvent(m.chainCh)
-	// TODO(rjl493456442): use feed to subscribe pending log event
-	m.pendingLogSub = m.mux.Subscribe(blockchain.PendingLogsEvent{})
 
 	// Make sure none of the subscriptions are empty
-	if m.txsSub == nil || m.logsSub == nil || m.rmLogsSub == nil || m.chainSub == nil ||
-		m.pendingLogSub.Closed() {
+	if m.txsSub == nil || m.logsSub == nil || m.rmLogsSub == nil || m.chainSub == nil {
 		logger.Crit("Subscribe for event system failed")
 	}
 
@@ -212,10 +200,11 @@ func (es *EventSystem) SubscribeLogs(crit kaia.FilterQuery, logs chan []*types.L
 		to = rpc.BlockNumber(crit.ToBlock.Int64())
 	}
 
-	// only interested in pending logs
-	if from == rpc.PendingBlockNumber && to == rpc.PendingBlockNumber {
-		return es.subscribePendingLogs(crit, logs), nil
+	// Pending logs are not supported anymore.
+	if from == rpc.PendingBlockNumber || to == rpc.PendingBlockNumber {
+		return nil, errPendingLogsUnsupported
 	}
+
 	// only interested in new mined logs
 	if from == rpc.LatestBlockNumber && to == rpc.LatestBlockNumber {
 		return es.subscribeLogs(crit, logs), nil
@@ -224,10 +213,6 @@ func (es *EventSystem) SubscribeLogs(crit kaia.FilterQuery, logs chan []*types.L
 	if from >= 0 && to >= 0 && to >= from {
 		return es.subscribeLogs(crit, logs), nil
 	}
-	// interested in mined logs from a specific block number, new logs and pending logs
-	if from >= rpc.LatestBlockNumber && to == rpc.PendingBlockNumber {
-		return es.subscribeMinedPendingLogs(crit, logs), nil
-	}
 	// interested in logs from a specific block number to new mined blocks
 	if from >= 0 && to == rpc.LatestBlockNumber {
 		return es.subscribeLogs(crit, logs), nil
@@ -235,23 +220,6 @@ func (es *EventSystem) SubscribeLogs(crit kaia.FilterQuery, logs chan []*types.L
 	return nil, fmt.Errorf("invalid from and to block combination: from > to")
 }
 
-// subscribeMinedPendingLogs creates a subscription that returned mined and
-// pending logs that match the given criteria.
-func (es *EventSystem) subscribeMinedPendingLogs(crit kaia.FilterQuery, logs chan []*types.Log) *Subscription {
-	sub := &subscription{
-		id:        rpc.NewID(),
-		typ:       MinedAndPendingLogsSubscription,
-		logsCrit:  crit,
-		created:   time.Now(),
-		logs:      logs,
-		hashes:    make(chan []common.Hash),
-		headers:   make(chan *types.Header),
-		installed: make(chan struct{}),
-		err:       make(chan error),
-	}
-	return es.subscribe(sub)
-}
-
 // subscribeLogs creates a subscription that will write all logs matching the
 // given criteria to the given logs channel.
 func (es *EventSystem) subscribeLogs(crit kaia.FilterQuery, logs chan []*types.Log) *Subscription {
@@ -269,23 +237,6 @@ func (es *EventSystem) subscribeLogs(crit kaia.FilterQuery, logs chan []*types.L
 	return es.subscribe(sub)
 }
 
-// subscribePendingLogs creates a subscription that writes transaction hashes for
-// transactions that enter the transaction pool.
-func (es *EventSystem) subscribePendingLogs(crit kaia.FilterQuery, logs chan []*types.Log) *Subscription {
-	sub := &subscription{
-		id:        rpc.NewID(),
-		typ:       PendingLogsSubscription,
-		logsCrit:  crit,
-		created:   time.Now(),
-		logs:      logs,
-		hashes:    make(chan []common.Hash),
-		headers:   make(chan *types.Header),
-		installed: make(chan struct{}),
-		err:       make(chan error),
-	}
-	return es.subscribe(sub)
-}
-
 // SubscribeNewHeads creates a subscription that writes the header of a block that is
 // imported in the chain.
 func (es *EventSystem) SubscribeNewHeads(headers chan *types.Header) *Subscription {
@@ -341,17 +292,6 @@ func (es *EventSystem) broadcast(filters filterIndex, ev interface{}) {
 				f.logs <- matchedLogs
 			}
 		}
-	case *event.TypeMuxEvent:
-		switch muxe := e.Data.(type) {
-		case blockchain.PendingLogsEvent:
-			for _, f := range filters[PendingLogsSubscription] {
-				if e.Time.After(f.created) {
-					if matchedLogs := filterLogs(muxe.Logs, nil, f.logsCrit.ToBlock, f.logsCrit.Addresses, f.logsCrit.Topics); len(matchedLogs) > 0 {
-						f.logs <- matchedLogs
-					}
-				}
-			}
-		}
 	case blockchain.NewTxsEvent:
 		hashes := make([]common.Hash, 0, len(e.Txs))
 		for _, tx := range e.Txs {
@@ -364,93 +304,13 @@ func (es *EventSystem) broadcast(filters filterIndex, ev interface{}) {
 		for _, f := range filters[BlocksSubscription] {
 			f.headers <- e.Block.Header()
 		}
-		if es.lightMode && len(filters[LogsSubscription]) > 0 {
-			es.lightFilterNewHead(e.Block.Header(), func(header *types.Header, remove bool) {
-				for _, f := range filters[LogsSubscription] {
-					if matchedLogs := es.lightFilterLogs(header, f.logsCrit.Addresses, f.logsCrit.Topics, remove); len(matchedLogs) > 0 {
-						f.logs <- matchedLogs
-					}
-				}
-			})
-		}
-	}
-}
-
-func (es *EventSystem) lightFilterNewHead(newHeader *types.Header, callBack func(*types.Header, bool)) {
-	oldh := es.lastHead
-	es.lastHead = newHeader
-	if oldh == nil {
-		return
-	}
-	newh := newHeader
-	// find common ancestor, create list of rolled back and new block hashes
-	var oldHeaders, newHeaders []*types.Header
-	for oldh.Hash() != newh.Hash() {
-		if oldh.Number.Uint64() >= newh.Number.Uint64() {
-			oldHeaders = append(oldHeaders, oldh)
-			oldh = es.backend.ChainDB().ReadHeader(oldh.ParentHash, oldh.Number.Uint64()-1)
-		}
-		if oldh.Number.Uint64() < newh.Number.Uint64() {
-			newHeaders = append(newHeaders, newh)
-			newh = es.backend.ChainDB().ReadHeader(newh.ParentHash, newh.Number.Uint64()-1)
-			if newh == nil {
-				// happens when CHT syncing, nothing to do
-				newh = oldh
-			}
-		}
-	}
-	// roll back old blocks
-	for _, h := range oldHeaders {
-		callBack(h, true)
-	}
-	// check new blocks (array is in reverse order)
-	for i := len(newHeaders) - 1; i >= 0; i-- {
-		callBack(newHeaders[i], false)
-	}
-}
-
-// filter logs of a single header in light client mode
-func (es *EventSystem) lightFilterLogs(header *types.Header, addresses []common.Address, topics [][]common.Hash, remove bool) []*types.Log {
-	if bloomFilter(header.Bloom, addresses, topics) {
-		// Get the logs of the block
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
-		defer cancel()
-		logsList, err := es.backend.GetLogs(ctx, header.Hash())
-		if err != nil {
-			return nil
-		}
-		var unfiltered []*types.Log
-		for _, logs := range logsList {
-			for _, log := range logs {
-				logcopy := *log
-				logcopy.Removed = remove
-				unfiltered = append(unfiltered, &logcopy)
-			}
-		}
-		logs := filterLogs(unfiltered, nil, nil, addresses, topics)
-		if len(logs) > 0 && logs[0].TxHash == (common.Hash{}) {
-			// We have matching but non-derived logs
-			receipts := es.backend.GetBlockReceipts(ctx, header.Hash())
-			unfiltered = unfiltered[:0]
-			for _, receipt := range receipts {
-				for _, log := range receipt.Logs {
-					logcopy := *log
-					logcopy.Removed = remove
-					unfiltered = append(unfiltered, &logcopy)
-				}
-			}
-			logs = filterLogs(unfiltered, nil, nil, addresses, topics)
-		}
-		return logs
 	}
-	return nil
 }
 
 // eventLoop (un)installs filters and processes mux events.
 func (es *EventSystem) eventLoop() {
 	// Ensure all subscriptions get cleaned up
 	defer func() {
-		es.pendingLogSub.Unsubscribe()
 		es.txsSub.Unsubscribe()
 		es.logsSub.Unsubscribe()
 		es.rmLogsSub.Unsubscribe()
@@ -473,30 +333,13 @@ func (es *EventSystem) eventLoop() {
 			es.broadcast(index, ev)
 		case ev := <-es.chainCh:
 			es.broadcast(index, ev)
-		case ev, active := <-es.pendingLogSub.Chan():
-			if !active { // system stopped
-				return
-			}
-			es.broadcast(index, ev)
 
 		case f := <-es.install:
-			if f.typ == MinedAndPendingLogsSubscription {
-				// the type are logs and pending logs subscriptions
-				index[LogsSubscription][f.id] = f
-				index[PendingLogsSubscription][f.id] = f
-			} else {
-				index[f.typ][f.id] = f
-			}
+			index[f.typ][f.id] = f
 			close(f.installed)
 
 		case f := <-es.uninstall:
-			if f.typ == MinedAndPendingLogsSubscription {
-				// the type are logs and pending logs subscriptions
-				delete(index[LogsSubscription], f.id)
-				delete(index[PendingLogsSubscription], f.id)
-			} else {
-				delete(index[f.typ], f.id)
-			}
+			delete(index[f.typ], f.id)
 			close(f.err)
 
 			// System stopped
diff --git a/node/cn/filters/filter_system_test.go b/node/cn/filters/filter_system_test.go
index 34f56e826..9ccf12c82 100644
--- a/node/cn/filters/filter_system_test.go
+++ b/node/cn/filters/filter_system_test.go
@@ -24,7 +24,6 @@ package filters
 
 import (
 	"context"
-	"fmt"
 	"math/big"
 	"math/rand"
 	"reflect"
@@ -32,9 +31,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/kaiachain/kaia"
 	"github.com/kaiachain/kaia/blockchain"
 	"github.com/kaiachain/kaia/blockchain/bloombits"
+	"github.com/kaiachain/kaia/blockchain/state"
 	"github.com/kaiachain/kaia/blockchain/types"
 	"github.com/kaiachain/kaia/common"
 	"github.com/kaiachain/kaia/consensus/gxhash"
@@ -45,14 +44,16 @@ import (
 )
 
 type testBackend struct {
-	mux         *event.TypeMux
-	db          database.DBManager
-	sections    uint64
-	txFeed      *event.Feed
-	rmLogsFeed  *event.Feed
-	logsFeed    *event.Feed
-	chainFeed   *event.Feed
-	chainConfig *params.ChainConfig
+	mux             *event.TypeMux
+	db              database.DBManager
+	sections        uint64
+	txFeed          *event.Feed
+	rmLogsFeed      *event.Feed
+	logsFeed        *event.Feed
+	chainFeed       *event.Feed
+	chainConfig     *params.ChainConfig
+	pendingBlock    *types.Block
+	pendingReceipts types.Receipts
 }
 
 /*
@@ -119,6 +120,10 @@ func (b *testBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*types
 	return logs, nil
 }
 
+func (b *testBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) {
+	return b.pendingBlock, b.pendingReceipts, nil
+}
+
 func (b *testBackend) SubscribeNewTxsEvent(ch chan<- blockchain.NewTxsEvent) event.Subscription {
 	return b.txFeed.Subscribe(ch)
 }
@@ -166,6 +171,22 @@ func (b *testBackend) ServiceFilter(ctx context.Context, session *bloombits.Matc
 	}()
 }
 
+func (b *testBackend) setPending(block *types.Block, receipts types.Receipts) {
+	b.pendingBlock = block
+	b.pendingReceipts = receipts
+}
+
+func (b *testBackend) notifyPending(logs []*types.Log) {
+	genesis := &blockchain.Genesis{
+		Config: params.TestChainConfig,
+	}
+	db := database.NewMemoryDBManager()
+	genesisBlock := genesis.MustCommit(db)
+	blocks, _ := blockchain.GenerateChain(genesis.Config, genesisBlock, gxhash.NewFaker(), db, 2, func(i int, b *blockchain.BlockGen) {})
+	b.setPending(blocks[1], []*types.Receipt{{Logs: logs}})
+	b.chainFeed.Send(blockchain.ChainEvent{Block: blocks[0]})
+}
+
 func (b *testBackend) ChainConfig() *params.ChainConfig {
 	return b.chainConfig
 }
@@ -185,11 +206,11 @@ func TestBlockSubscription(t *testing.T) {
 		rmLogsFeed  = new(event.Feed)
 		logsFeed    = new(event.Feed)
 		chainFeed   = new(event.Feed)
-		backend     = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig}
-		api         = NewPublicFilterAPI(backend, false)
+		backend     = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig, nil, nil}
+		api         = NewPublicFilterAPI(backend)
 		genesis     = new(blockchain.Genesis).MustCommit(db)
 		chain, _    = blockchain.GenerateChain(params.TestChainConfig, genesis, gxhash.NewFaker(), db, 10, func(i int, gen *blockchain.BlockGen) {})
-		chainEvents = []blockchain.ChainEvent{}
+		chainEvents []blockchain.ChainEvent
 	)
 
 	for _, blk := range chain {
@@ -242,8 +263,8 @@ func TestPendingTxFilter(t *testing.T) {
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig}
-		api        = NewPublicFilterAPI(backend, false)
+		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig, nil, nil}
+		api        = NewPublicFilterAPI(backend)
 
 		transactions = []*types.Transaction{
 			types.NewTransaction(0, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), 0, new(big.Int), nil),
@@ -302,8 +323,8 @@ func TestLogFilterCreation(t *testing.T) {
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig}
-		api        = NewPublicFilterAPI(backend, false)
+		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig, nil, nil}
+		api        = NewPublicFilterAPI(backend)
 
 		testCases = []struct {
 			crit    FilterCriteria
@@ -315,26 +336,31 @@ func TestLogFilterCreation(t *testing.T) {
 			{FilterCriteria{FromBlock: big.NewInt(1), ToBlock: big.NewInt(2)}, true},
 			// "mined" block range to pending
 			{FilterCriteria{FromBlock: big.NewInt(1), ToBlock: big.NewInt(rpc.LatestBlockNumber.Int64())}, true},
-			// new mined and pending blocks
-			{FilterCriteria{FromBlock: big.NewInt(rpc.LatestBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64())}, true},
 			// from block "higher" than to block
 			{FilterCriteria{FromBlock: big.NewInt(2), ToBlock: big.NewInt(1)}, false},
 			// from block "higher" than to block
 			{FilterCriteria{FromBlock: big.NewInt(rpc.LatestBlockNumber.Int64()), ToBlock: big.NewInt(100)}, false},
-			// from block "higher" than to block
+			// errPendingLogsUnsupported
 			{FilterCriteria{FromBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), ToBlock: big.NewInt(100)}, false},
-			// from block "higher" than to block
+			// errPendingLogsUnsupported
 			{FilterCriteria{FromBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), ToBlock: big.NewInt(rpc.LatestBlockNumber.Int64())}, false},
+			// errPendingLogsUnsupported
+			{FilterCriteria{FromBlock: big.NewInt(rpc.LatestBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64())}, false},
+			// topics more than 4 // NOTE: Kaia doesn't support errExceedMaxTopics
+			{FilterCriteria{Topics: [][]common.Hash{{}, {}, {}, {}, {}}}, true},
 		}
 	)
 
 	for i, test := range testCases {
-		_, err := api.NewFilter(test.crit)
+		id, err := api.NewFilter(test.crit)
 		if test.success && err != nil {
 			t.Errorf("expected filter creation for case %d to success, got %v", i, err)
 		}
-		if !test.success && err == nil {
-			t.Errorf("expected testcase %d to fail with an error", i)
+		if err == nil {
+			api.UninstallFilter(id)
+			if !test.success {
+				t.Errorf("expected testcase %d to fail with an error", i)
+			}
 		}
 	}
 }
@@ -351,8 +377,8 @@ func TestInvalidLogFilterCreation(t *testing.T) {
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig}
-		api        = NewPublicFilterAPI(backend, false)
+		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig, nil, nil}
+		api        = NewPublicFilterAPI(backend)
 	)
 
 	// different situations where log filter creation should fail.
@@ -378,8 +404,8 @@ func TestInvalidGetLogsRequest(t *testing.T) {
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig}
-		api        = NewPublicFilterAPI(backend, false)
+		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig, nil, nil}
+		api        = NewPublicFilterAPI(backend)
 		blockHash  = common.HexToHash("0x1111111111111111111111111111111111111111111111111111111111111111")
 	)
 
@@ -408,8 +434,8 @@ func TestLogFilter(t *testing.T) {
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig}
-		api        = NewPublicFilterAPI(backend, false)
+		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig, nil, nil}
+		api        = NewPublicFilterAPI(backend)
 
 		firstAddr      = common.HexToAddress("0x1111111111111111111111111111111111111111")
 		secondAddr     = common.HexToAddress("0x2222222222222222222222222222222222222222")
@@ -428,9 +454,6 @@ func TestLogFilter(t *testing.T) {
 			{Address: thirdAddress, Topics: []common.Hash{secondTopic}, BlockNumber: 3},
 		}
 
-		expectedCase7  = []*types.Log{allLogs[3], allLogs[4], allLogs[0], allLogs[1], allLogs[2], allLogs[3], allLogs[4]}
-		expectedCase11 = []*types.Log{allLogs[1], allLogs[2], allLogs[1], allLogs[2]}
-
 		testCases = []struct {
 			crit     FilterCriteria
 			expected []*types.Log
@@ -448,20 +471,14 @@ func TestLogFilter(t *testing.T) {
 			4: {FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, allLogs[3:5], ""},
 			// match logs based on multiple addresses and "or" topics
 			5: {FilterCriteria{Addresses: []common.Address{secondAddr, thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, allLogs[2:5], ""},
-			// logs in the pending block
-			6: {FilterCriteria{Addresses: []common.Address{firstAddr}, FromBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64())}, allLogs[:2], ""},
-			// mined logs with block num >= 2 or pending logs
-			7: {FilterCriteria{FromBlock: big.NewInt(2), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64())}, expectedCase7, ""},
 			// all "mined" logs with block num >= 2
-			8: {FilterCriteria{FromBlock: big.NewInt(2), ToBlock: big.NewInt(rpc.LatestBlockNumber.Int64())}, allLogs[3:], ""},
+			6: {FilterCriteria{FromBlock: big.NewInt(2), ToBlock: big.NewInt(rpc.LatestBlockNumber.Int64())}, allLogs[3:], ""},
 			// all "mined" logs
-			9: {FilterCriteria{ToBlock: big.NewInt(rpc.LatestBlockNumber.Int64())}, allLogs, ""},
+			7: {FilterCriteria{ToBlock: big.NewInt(rpc.LatestBlockNumber.Int64())}, allLogs, ""},
 			// all "mined" logs with 1>= block num <=2 and topic secondTopic
-			10: {FilterCriteria{FromBlock: big.NewInt(1), ToBlock: big.NewInt(2), Topics: [][]common.Hash{{secondTopic}}}, allLogs[3:4], ""},
-			// all "mined" and pending logs with topic firstTopic
-			11: {FilterCriteria{FromBlock: big.NewInt(rpc.LatestBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), Topics: [][]common.Hash{{firstTopic}}}, expectedCase11, ""},
+			8: {FilterCriteria{FromBlock: big.NewInt(1), ToBlock: big.NewInt(2), Topics: [][]common.Hash{{secondTopic}}}, allLogs[3:4], ""},
 			// match all logs due to wildcard topic
-			12: {FilterCriteria{Topics: [][]common.Hash{nil}}, allLogs[1:], ""},
+			9: {FilterCriteria{Topics: [][]common.Hash{nil}}, allLogs[1:], ""},
 		}
 	)
 
@@ -475,9 +492,9 @@ func TestLogFilter(t *testing.T) {
 	if nsend := logsFeed.Send(allLogs); nsend == 0 {
 		t.Fatal("Shoud have at least one subscription")
 	}
-	if err := mux.Post(blockchain.PendingLogsEvent{Logs: allLogs}); err != nil {
-		t.Fatal(err)
-	}
+
+	// set pending logs
+	backend.notifyPending(allLogs)
 
 	for i, tt := range testCases {
 		var fetched []*types.Log
@@ -485,7 +502,7 @@ func TestLogFilter(t *testing.T) {
 		for { // fetch all expected logs
 			results, err := api.GetFilterChanges(tt.id)
 			if err != nil {
-				t.Fatalf("Unable to fetch logs: %v", err)
+				t.Fatalf("test %d: unable to fetch logs: %v", i, err)
 			}
 
 			fetched = append(fetched, results.([]*types.Log)...)
@@ -516,124 +533,6 @@ func TestLogFilter(t *testing.T) {
 	}
 }
 
-// TestPendingLogsSubscription tests if a subscription receives the correct pending logs that are posted to the event feed.
-func TestPendingLogsSubscription(t *testing.T) {
-	t.Parallel()
-
-	var (
-		mux        = new(event.TypeMux)
-		db         = database.NewMemoryDBManager()
-		txFeed     = new(event.Feed)
-		rmLogsFeed = new(event.Feed)
-		logsFeed   = new(event.Feed)
-		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig}
-		api        = NewPublicFilterAPI(backend, false)
-
-		firstAddr      = common.HexToAddress("0x1111111111111111111111111111111111111111")
-		secondAddr     = common.HexToAddress("0x2222222222222222222222222222222222222222")
-		thirdAddress   = common.HexToAddress("0x3333333333333333333333333333333333333333")
-		notUsedAddress = common.HexToAddress("0x9999999999999999999999999999999999999999")
-		firstTopic     = common.HexToHash("0x1111111111111111111111111111111111111111111111111111111111111111")
-		secondTopic    = common.HexToHash("0x2222222222222222222222222222222222222222222222222222222222222222")
-		thirdTopic     = common.HexToHash("0x3333333333333333333333333333333333333333333333333333333333333333")
-		fourthTopic    = common.HexToHash("0x4444444444444444444444444444444444444444444444444444444444444444")
-		notUsedTopic   = common.HexToHash("0x9999999999999999999999999999999999999999999999999999999999999999")
-
-		allLogs = []blockchain.PendingLogsEvent{
-			{Logs: []*types.Log{{Address: firstAddr, Topics: []common.Hash{}, BlockNumber: 0}}},
-			{Logs: []*types.Log{{Address: firstAddr, Topics: []common.Hash{firstTopic}, BlockNumber: 1}}},
-			{Logs: []*types.Log{{Address: secondAddr, Topics: []common.Hash{firstTopic}, BlockNumber: 2}}},
-			{Logs: []*types.Log{{Address: thirdAddress, Topics: []common.Hash{secondTopic}, BlockNumber: 3}}},
-			{Logs: []*types.Log{{Address: thirdAddress, Topics: []common.Hash{secondTopic}, BlockNumber: 4}}},
-			{Logs: []*types.Log{
-				{Address: thirdAddress, Topics: []common.Hash{firstTopic}, BlockNumber: 5},
-				{Address: thirdAddress, Topics: []common.Hash{thirdTopic}, BlockNumber: 5},
-				{Address: thirdAddress, Topics: []common.Hash{fourthTopic}, BlockNumber: 5},
-				{Address: firstAddr, Topics: []common.Hash{firstTopic}, BlockNumber: 5},
-			}},
-		}
-
-		convertLogs = func(pl []blockchain.PendingLogsEvent) []*types.Log {
-			var logs []*types.Log
-			for _, l := range pl {
-				logs = append(logs, l.Logs...)
-			}
-			return logs
-		}
-
-		testCases = []struct {
-			crit     kaia.FilterQuery
-			expected []*types.Log
-			c        chan []*types.Log
-			sub      *Subscription
-		}{
-			// match all
-			{kaia.FilterQuery{}, convertLogs(allLogs), nil, nil},
-			// match none due to no matching addresses
-			{kaia.FilterQuery{Addresses: []common.Address{{}, notUsedAddress}, Topics: [][]common.Hash{nil}}, []*types.Log{}, nil, nil},
-			// match logs based on addresses, ignore topics
-			{kaia.FilterQuery{Addresses: []common.Address{firstAddr}}, append(convertLogs(allLogs[:2]), allLogs[5].Logs[3]), nil, nil},
-			// match none due to no matching topics (match with address)
-			{kaia.FilterQuery{Addresses: []common.Address{secondAddr}, Topics: [][]common.Hash{{notUsedTopic}}}, []*types.Log{}, nil, nil},
-			// match logs based on addresses and topics
-			{kaia.FilterQuery{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, append(convertLogs(allLogs[3:5]), allLogs[5].Logs[0]), nil, nil},
-			// match logs based on multiple addresses and "or" topics
-			{kaia.FilterQuery{Addresses: []common.Address{secondAddr, thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, append(convertLogs(allLogs[2:5]), allLogs[5].Logs[0]), nil, nil},
-			// block numbers are ignored for filters created with New***Filter, these return all logs that match the given criteria when the state changes
-			{kaia.FilterQuery{Addresses: []common.Address{firstAddr}, FromBlock: big.NewInt(2), ToBlock: big.NewInt(3)}, append(convertLogs(allLogs[:2]), allLogs[5].Logs[3]), nil, nil},
-			// multiple pending logs, should match only 2 topics from the logs in block 5
-			{kaia.FilterQuery{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{{firstTopic, fourthTopic}}}, []*types.Log{allLogs[5].Logs[0], allLogs[5].Logs[2]}, nil, nil},
-		}
-	)
-
-	// create all subscriptions, this ensures all subscriptions are created before the events are posted.
-	// on slow machines this could otherwise lead to missing events when the subscription is created after
-	// (some) events are posted.
-	for i := range testCases {
-		testCases[i].c = make(chan []*types.Log)
-		testCases[i].sub, _ = api.events.SubscribeLogs(testCases[i].crit, testCases[i].c)
-	}
-
-	for n, test := range testCases {
-		i := n
-		tt := test
-		go func() {
-			var fetched []*types.Log
-		fetchLoop:
-			for {
-				logs := <-tt.c
-				fetched = append(fetched, logs...)
-				if len(fetched) >= len(tt.expected) {
-					break fetchLoop
-				}
-			}
-
-			if len(fetched) != len(tt.expected) {
-				panic(fmt.Sprintf("invalid number of logs for case %d, want %d log(s), got %d", i, len(tt.expected), len(fetched)))
-			}
-
-			for l := range fetched {
-				if fetched[l].Removed {
-					panic(fmt.Sprintf("expected log not to be removed for log %d in case %d", l, i))
-				}
-				if !reflect.DeepEqual(fetched[l], tt.expected[l]) {
-					panic(fmt.Sprintf("invalid log on index %d for case %d", l, i))
-				}
-			}
-		}()
-	}
-
-	// raise events
-	time.Sleep(1 * time.Second)
-	// allLogs are type of blockchain.PendingLogsEvent
-	for _, l := range allLogs {
-		if err := mux.Post(l); err != nil {
-			t.Fatal(err)
-		}
-	}
-}
-
 // TestPendingTxFilterDeadlock tests if the event loop hangs when pending
 // txs arrive at the same time that one of multiple filters is timing out.
 func TestPendingTxFilterDeadlock(t *testing.T) {
@@ -647,7 +546,7 @@ func TestPendingTxFilterDeadlock(t *testing.T) {
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig}
+		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig, nil, nil}
 		done       = make(chan struct{})
 	)
 
@@ -657,7 +556,7 @@ func TestPendingTxFilterDeadlock(t *testing.T) {
 		backend: backend,
 		mux:     backend.EventMux(),
 		chainDB: backend.ChainDB(),
-		events:  NewEventSystem(backend.EventMux(), backend, false),
+		events:  NewEventSystem(backend.EventMux(), backend),
 		filters: make(map[rpc.ID]*filter),
 		timeout: timeout,
 	}
diff --git a/node/cn/filters/filter_test.go b/node/cn/filters/filter_test.go
index c50330928..b75c56457 100644
--- a/node/cn/filters/filter_test.go
+++ b/node/cn/filters/filter_test.go
@@ -24,8 +24,10 @@ package filters
 
 import (
 	"context"
+	"encoding/json"
 	"math/big"
 	"testing"
+	"time"
 
 	"github.com/golang/mock/gomock"
 	"github.com/kaiachain/kaia/blockchain"
@@ -100,10 +102,10 @@ func TestFilter_Logs(t *testing.T) {
 	ctx := context.Background()
 	{
 		mockCtrl, mockBackend, newFilter := genFilter(t)
-		mockBackend.EXPECT().HeaderByNumber(ctx, rpc.LatestBlockNumber).Times(1).Return(nil, nil)
+		mockBackend.EXPECT().HeaderByNumber(ctx, rpc.LatestBlockNumber).Times(1).Return(nil, errors.New("latest header not found"))
 		logs, err := newFilter.Logs(ctx)
 		assert.Nil(t, logs)
-		assert.NoError(t, err)
+		assert.Error(t, err)
 		mockCtrl.Finish()
 	}
 }
@@ -177,7 +179,7 @@ func BenchmarkFilters(b *testing.B) {
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig}
+		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig, nil, nil}
 		key1, _    = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		addr1      = crypto.PubkeyToAddress(key1.PublicKey)
 		addr2      = common.BytesToAddress([]byte("jeff"))
@@ -240,7 +242,7 @@ func TestFilters(t *testing.T) {
 		rmLogsFeed = new(event.Feed)
 		logsFeed   = new(event.Feed)
 		chainFeed  = new(event.Feed)
-		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig}
+		backend    = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed, params.TestChainConfig, nil, nil}
 		key1, _    = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		addr       = crypto.PubkeyToAddress(key1.PublicKey)
 
@@ -304,58 +306,85 @@ func TestFilters(t *testing.T) {
 		db.WriteReceipts(block.Hash(), block.NumberU64(), receipts[i])
 	}
 
-	filter := NewRangeFilter(backend, 0, -1, []common.Address{addr}, [][]common.Hash{{hash1, hash2, hash3, hash4}})
-
-	logs, _ := filter.Logs(context.Background())
-	if len(logs) != 4 {
-		t.Error("expected 4 log, got", len(logs))
-	}
-
-	filter = NewRangeFilter(backend, 900, 999, []common.Address{addr}, [][]common.Hash{{hash3}})
-	logs, _ = filter.Logs(context.Background())
-	if len(logs) != 1 {
-		t.Error("expected 1 log, got", len(logs))
-	}
-	if len(logs) > 0 && logs[0].Topics[0] != hash3 {
-		t.Errorf("expected log[0].Topics[0] to be %x, got %x", hash3, logs[0].Topics[0])
-	}
-
-	filter = NewRangeFilter(backend, 990, -1, []common.Address{addr}, [][]common.Hash{{hash3}})
-	logs, _ = filter.Logs(context.Background())
-	if len(logs) != 1 {
-		t.Error("expected 1 log, got", len(logs))
-	}
-	if len(logs) > 0 && logs[0].Topics[0] != hash3 {
-		t.Errorf("expected log[0].Topics[0] to be %x, got %x", hash3, logs[0].Topics[0])
-	}
-
-	filter = NewRangeFilter(backend, 1, 10, nil, [][]common.Hash{{hash1, hash2}})
-
-	logs, _ = filter.Logs(context.Background())
-	if len(logs) != 2 {
-		t.Error("expected 2 log, got", len(logs))
-	}
-
-	failHash := common.BytesToHash([]byte("fail"))
-	filter = NewRangeFilter(backend, 0, -1, nil, [][]common.Hash{{failHash}})
-
-	logs, _ = filter.Logs(context.Background())
-	if len(logs) != 0 {
-		t.Error("expected 0 log, got", len(logs))
-	}
-
-	failAddr := common.BytesToAddress([]byte("failmenow"))
-	filter = NewRangeFilter(backend, 0, -1, []common.Address{failAddr}, nil)
-
-	logs, _ = filter.Logs(context.Background())
-	if len(logs) != 0 {
-		t.Error("expected 0 log, got", len(logs))
+	for i, tc := range []struct {
+		f    *Filter
+		want string
+		err  string
+	}{
+		{
+			f:    NewRangeFilter(backend, 0, int64(rpc.LatestBlockNumber), []common.Address{addr}, [][]common.Hash{{hash1, hash2, hash3, hash4}}),
+			want: `[{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false},{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false},{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false},{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false}]`,
+		},
+		{
+			f:    NewRangeFilter(backend, 900, 999, []common.Address{addr}, [][]common.Hash{{hash3}}),
+			want: `[{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false}]`,
+		},
+		{
+			f:    NewRangeFilter(backend, 990, int64(rpc.LatestBlockNumber), []common.Address{addr}, [][]common.Hash{{hash3}}),
+			want: `[{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696333"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false}]`,
+		},
+		{
+			f:    NewRangeFilter(backend, 1, 10, []common.Address{addr}, [][]common.Hash{{hash1, hash2}}),
+			want: `[{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false},{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false}]`,
+		},
+		{
+			f:    NewRangeFilter(backend, 1, 10, nil, [][]common.Hash{{hash1, hash2}}),
+			want: `[{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696331"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false},{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696332"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false}]`,
+		},
+		{
+			f: NewRangeFilter(backend, 0, int64(rpc.LatestBlockNumber), nil, [][]common.Hash{{common.BytesToHash([]byte("fail"))}}),
+		},
+		{
+			f: NewRangeFilter(backend, 0, int64(rpc.LatestBlockNumber), []common.Address{common.BytesToAddress([]byte("failmenow"))}, nil),
+		},
+		{
+			f: NewRangeFilter(backend, 0, int64(rpc.LatestBlockNumber), nil, [][]common.Hash{{common.BytesToHash([]byte("fail"))}, {hash1}}),
+		},
+		{
+			f:    NewRangeFilter(backend, int64(rpc.LatestBlockNumber), int64(rpc.LatestBlockNumber), nil, nil),
+			want: `[{"address":"0x71562b71999873db5b286df957af199ec94617f7","topics":["0x0000000000000000000000000000000000000000000000000000746f70696334"],"data":"0x","blockNumber":"0x0","transactionHash":"0x0000000000000000000000000000000000000000000000000000000000000000","transactionIndex":"0x0","blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","logIndex":"0x0","removed":false}]`,
+		},
+		{
+			f:   NewRangeFilter(backend, int64(rpc.PendingBlockNumber), int64(rpc.PendingBlockNumber), nil, nil),
+			err: errPendingLogsUnsupported.Error(),
+		},
+		{
+			f:   NewRangeFilter(backend, int64(rpc.LatestBlockNumber), int64(rpc.PendingBlockNumber), nil, nil),
+			err: errPendingLogsUnsupported.Error(),
+		},
+		{
+			f:   NewRangeFilter(backend, int64(rpc.PendingBlockNumber), int64(rpc.LatestBlockNumber), nil, nil),
+			err: errPendingLogsUnsupported.Error(),
+		},
+	} {
+		logs, err := tc.f.Logs(context.Background())
+		if err == nil && tc.err != "" {
+			t.Fatalf("test %d, expected error %q, got nil", i, tc.err)
+		} else if err != nil && err.Error() != tc.err {
+			t.Fatalf("test %d, expected error %q, got %q", i, tc.err, err.Error())
+		}
+		if tc.want == "" && len(logs) == 0 {
+			continue
+		}
+		have, err := json.Marshal(logs)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(have) != tc.want {
+			t.Fatalf("test %d, have:\n%s\nwant:\n%s", i, have, tc.want)
+		}
 	}
 
-	filter = NewRangeFilter(backend, 0, -1, nil, [][]common.Hash{{failHash}, {hash1}})
-
-	logs, _ = filter.Logs(context.Background())
-	if len(logs) != 0 {
-		t.Error("expected 0 log, got", len(logs))
-	}
+	t.Run("timeout", func(t *testing.T) {
+		f := NewRangeFilter(backend, 0, rpc.LatestBlockNumber.Int64(), nil, nil)
+		ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(-time.Hour))
+		defer cancel()
+		_, err := f.Logs(ctx)
+		if err == nil {
+			t.Fatal("expected error")
+		}
+		if err.Error() != errors.New("query timeout exceeded").Error() {
+			t.Fatalf("expected context.DeadlineExceeded, got %v", err)
+		}
+	})
 }
diff --git a/node/cn/filters/mock/backend_mock.go b/node/cn/filters/mock/backend_mock.go
index 2e1574b64..7d9238eed 100644
--- a/node/cn/filters/mock/backend_mock.go
+++ b/node/cn/filters/mock/backend_mock.go
@@ -11,6 +11,7 @@ import (
 	gomock "github.com/golang/mock/gomock"
 	blockchain "github.com/kaiachain/kaia/blockchain"
 	bloombits "github.com/kaiachain/kaia/blockchain/bloombits"
+	state "github.com/kaiachain/kaia/blockchain/state"
 	types "github.com/kaiachain/kaia/blockchain/types"
 	common "github.com/kaiachain/kaia/common"
 	event "github.com/kaiachain/kaia/event"
@@ -158,6 +159,22 @@ func (mr *MockBackendMockRecorder) HeaderByNumber(arg0, arg1 interface{}) *gomoc
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByNumber", reflect.TypeOf((*MockBackend)(nil).HeaderByNumber), arg0, arg1)
 }
 
+// Pending mocks base method.
+func (m *MockBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Pending")
+	ret0, _ := ret[0].(*types.Block)
+	ret1, _ := ret[1].(types.Receipts)
+	ret2, _ := ret[2].(*state.StateDB)
+	return ret0, ret1, ret2
+}
+
+// Pending indicates an expected call of Pending.
+func (mr *MockBackendMockRecorder) Pending() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pending", reflect.TypeOf((*MockBackend)(nil).Pending))
+}
+
 // ServiceFilter mocks base method.
 func (m *MockBackend) ServiceFilter(arg0 context.Context, arg1 *bloombits.MatcherSession) {
 	m.ctrl.T.Helper()
diff --git a/node/cn/gasprice/feehistory.go b/node/cn/gasprice/feehistory.go
index c854f972b..90d79db7c 100644
--- a/node/cn/gasprice/feehistory.go
+++ b/node/cn/gasprice/feehistory.go
@@ -167,38 +167,67 @@ func (oracle *Oracle) processBlock(bf *blockFees, percentiles []float64) {
 }
 
 // resolveBlockRange resolves the specified block range to absolute block numbers while also
-// enforcing backend specific limitations.
-// Pending block does not exist in Kaia, so there is no logic to look up pending blocks.
-// This part has a different implementation with Ethereum.
+// enforcing backend specific limitations. The pending block and corresponding receipts are
+// also returned if requested and available.
 // Note: an error is only returned if retrieving the head header has failed. If there are no
 // retrievable blocks in the specified range then zero block count is returned with no error.
-func (oracle *Oracle) resolveBlockRange(ctx context.Context, lastBlock rpc.BlockNumber, blocks int) (uint64, int, error) {
-	var headBlock rpc.BlockNumber
-	// query either pending block or head header and set headBlock
-	if lastBlock == rpc.PendingBlockNumber {
-		// pending block not supported by backend, process until latest block
-		lastBlock = rpc.LatestBlockNumber
-		blocks--
-		if blocks == 0 {
-			return 0, 0, nil
-		}
+func (oracle *Oracle) resolveBlockRange(ctx context.Context, reqEnd rpc.BlockNumber, blocks uint64) (*types.Block, []*types.Receipt, uint64, uint64, error) {
+	var (
+		headBlock       *types.Header
+		pendingBlock    *types.Block
+		pendingReceipts types.Receipts
+		err             error
+	)
+
+	// Get the chain's current head.
+	if headBlock, err = oracle.backend.HeaderByNumber(ctx, rpc.LatestBlockNumber); err != nil {
+		return nil, nil, 0, 0, err
 	}
-	// if pending block is not fetched then we retrieve the head header to get the head block number
-	if latestHeader, err := oracle.backend.HeaderByNumber(ctx, rpc.LatestBlockNumber); err == nil {
-		headBlock = rpc.BlockNumber(latestHeader.Number.Uint64())
-	} else {
-		return 0, 0, err
+	head := rpc.BlockNumber(headBlock.Number.Uint64())
+
+	// Fail if request block is beyond the chain's current head.
+	if head < reqEnd {
+		return nil, nil, 0, 0, fmt.Errorf("%w: requested %d, head %d", errRequestBeyondHead, reqEnd, head)
 	}
-	if lastBlock == rpc.LatestBlockNumber {
-		lastBlock = headBlock
-	} else if lastBlock > headBlock {
-		return 0, 0, fmt.Errorf("%w: requested %d, head %d", errRequestBeyondHead, lastBlock, headBlock)
+
+	// Resolve block tag.
+	if reqEnd < 0 {
+		var (
+			resolved *types.Header
+			err      error
+		)
+		switch reqEnd {
+		case rpc.PendingBlockNumber:
+			if pendingBlock, pendingReceipts, _ = oracle.backend.Pending(); pendingBlock != nil {
+				resolved = pendingBlock.Header()
+			} else {
+				// Pending block not supported by backend, process only until latest block.
+				resolved = headBlock
+				// Update total blocks to return to account for this.
+				blocks--
+			}
+		case rpc.LatestBlockNumber:
+			// Retrieved above.
+			resolved = headBlock
+		case rpc.EarliestBlockNumber:
+			resolved, err = oracle.backend.HeaderByNumber(ctx, rpc.EarliestBlockNumber)
+		}
+		if resolved == nil || err != nil {
+			return nil, nil, 0, 0, err
+		}
+		// Absolute number resolved.
+		reqEnd = rpc.BlockNumber(resolved.Number.Uint64())
+	}
+
+	// If there are no blocks to return, short circuit.
+	if blocks == 0 {
+		return nil, nil, 0, 0, nil
 	}
-	// ensure not trying to retrieve before genesis
-	if rpc.BlockNumber(blocks) > lastBlock+1 {
-		blocks = int(lastBlock + 1)
+	// Ensure not trying to retrieve before genesis.
+	if uint64(reqEnd+1) < blocks {
+		blocks = uint64(reqEnd + 1)
 	}
-	return uint64(lastBlock), blocks, nil
+	return pendingBlock, pendingReceipts, uint64(reqEnd), blocks, nil
 }
 
 // FeeHistory returns data relevant for fee estimation based on the specified range of blocks.
@@ -216,7 +245,7 @@ func (oracle *Oracle) resolveBlockRange(ctx context.Context, lastBlock rpc.Block
 // Note: baseFee includes the next block after the newest of the returned range, because this
 // value can be derived from the newest block.
 func (oracle *Oracle) FeeHistory(
-	ctx context.Context, blocks int,
+	ctx context.Context, blocks uint64,
 	unresolvedLastBlock rpc.BlockNumber,
 	rewardPercentiles []float64,
 ) (*big.Int, [][]*big.Int, []*big.Int, []float64, error) {
@@ -243,7 +272,7 @@ func (oracle *Oracle) FeeHistory(
 		}
 	}
 	var err error
-	lastBlock, blocks, err := oracle.resolveBlockRange(ctx, unresolvedLastBlock, blocks)
+	pendingBlock, pendingReceipts, lastBlock, blocks, err := oracle.resolveBlockRange(ctx, unresolvedLastBlock, blocks)
 	if err != nil || blocks == 0 {
 		return common.Big0, nil, nil, nil, err
 	}
@@ -257,7 +286,7 @@ func (oracle *Oracle) FeeHistory(
 	for i, p := range rewardPercentiles {
 		binary.LittleEndian.PutUint64(percentileKey[i*8:(i+1)*8], math.Float64bits(p))
 	}
-	for i := 0; i < maxBlockFetchers && i < blocks; i++ {
+	for i := 0; i < maxBlockFetchers && i < int(blocks); i++ {
 		go func() {
 			for {
 				// Retrieve the next block number to fetch with this goroutine
@@ -267,29 +296,35 @@ func (oracle *Oracle) FeeHistory(
 				}
 
 				fees := &blockFees{blockNumber: blockNumber}
-				cacheKey := cacheKey{number: blockNumber, percentiles: string(percentileKey)}
-
-				if p, ok := oracle.historyCache.Get(cacheKey); ok {
-					fees.results = p.(processedFees)
+				if pendingBlock != nil && blockNumber >= pendingBlock.NumberU64() {
+					fees.block, fees.receipts = pendingBlock, pendingReceipts
+					fees.header = fees.block.Header()
+					oracle.processBlock(fees, rewardPercentiles)
 					results <- fees
 				} else {
-					if len(rewardPercentiles) != 0 {
-						fees.block, fees.err = oracle.backend.BlockByNumber(ctx, rpc.BlockNumber(blockNumber))
-						if fees.block != nil && fees.err == nil {
-							fees.receipts = oracle.backend.GetBlockReceipts(ctx, fees.block.Hash())
-							fees.header = fees.block.Header()
-						}
+					cacheKey := cacheKey{number: blockNumber, percentiles: string(percentileKey)}
+					if p, ok := oracle.historyCache.Get(cacheKey); ok {
+						fees.results = p.(processedFees)
+						results <- fees
 					} else {
-						fees.header, fees.err = oracle.backend.HeaderByNumber(ctx, rpc.BlockNumber(blockNumber))
-					}
-					if fees.header != nil && fees.err == nil {
-						oracle.processBlock(fees, rewardPercentiles)
-						if fees.err == nil {
-							oracle.historyCache.Add(cacheKey, fees.results)
+						if len(rewardPercentiles) != 0 {
+							fees.block, fees.err = oracle.backend.BlockByNumber(ctx, rpc.BlockNumber(blockNumber))
+							if fees.block != nil && fees.err == nil {
+								fees.receipts = oracle.backend.GetBlockReceipts(ctx, fees.block.Hash())
+								fees.header = fees.block.Header()
+							}
+						} else {
+							fees.header, fees.err = oracle.backend.HeaderByNumber(ctx, rpc.BlockNumber(blockNumber))
 						}
+						if fees.header != nil && fees.err == nil {
+							oracle.processBlock(fees, rewardPercentiles)
+							if fees.err == nil {
+								oracle.historyCache.Add(cacheKey, fees.results)
+							}
+						}
+						// send to results even if empty to guarantee that blocks items are sent in total
+						results <- fees
 					}
-					// send to results even if empty to guarantee that blocks items are sent in total
-					results <- fees
 				}
 			}
 		}()
@@ -305,7 +340,7 @@ func (oracle *Oracle) FeeHistory(
 		if fees.err != nil {
 			return common.Big0, nil, nil, nil, fees.err
 		}
-		i := int(fees.blockNumber - oldestBlock)
+		i := fees.blockNumber - oldestBlock
 		if fees.results.baseFee != nil {
 			reward[i], baseFee[i], baseFee[i+1], gasUsedRatio[i] = fees.results.reward, fees.results.baseFee, fees.results.nextBaseFee, fees.results.gasUsedRatio
 		} else {
diff --git a/node/cn/gasprice/feehistory_test.go b/node/cn/gasprice/feehistory_test.go
index 6308846b1..d85dd8cc4 100644
--- a/node/cn/gasprice/feehistory_test.go
+++ b/node/cn/gasprice/feehistory_test.go
@@ -35,36 +35,38 @@ import (
 func TestFeeHistory(t *testing.T) {
 	log.EnableLogForTest(log.LvlCrit, log.LvlError)
 	cases := []struct {
-		maxHeader, maxBlock int
-		count               int
+		pending             bool
+		maxHeader, maxBlock uint64
+		count               uint64
 		last                rpc.BlockNumber
 		percent             []float64
 		expFirst            uint64
 		expCount            int
 		expErr              error
 	}{
-		{1000, 1000, 10, 30, nil, 21, 10, nil},
-		{1000, 1000, 10, 30, []float64{0, 10}, 21, 10, nil},
-		{1000, 1000, 10, 30, []float64{20, 10}, 0, 0, fmt.Errorf("%w: #%d:%f > #%d:%f", errInvalidPercentile, 0, 20.0000, 1, 10.0000)},
-		{1000, 1000, 1000000000, 30, nil, 0, 31, nil},
-		{1000, 1000, 1000000000, rpc.LatestBlockNumber, nil, 0, 33, nil},
-		{1000, 1000, 10, 40, nil, 0, 0, fmt.Errorf("%w: requested %d, head %d", errRequestBeyondHead, 40, 32)},
-		{20, 2, 100, rpc.LatestBlockNumber, nil, 13, 20, nil},
-		{20, 2, 100, rpc.LatestBlockNumber, []float64{0, 10}, 31, 2, nil},
-		{20, 2, 100, 32, []float64{0, 10}, 31, 2, nil},
-		{1000, 1000, 1, rpc.PendingBlockNumber, nil, 0, 0, nil},
-		{1000, 1000, 2, rpc.PendingBlockNumber, nil, 32, 1, nil},
+		{false, 1000, 1000, 10, 30, nil, 21, 10, nil},
+		{false, 1000, 1000, 10, 30, []float64{0, 10}, 21, 10, nil},
+		{false, 1000, 1000, 10, 30, []float64{20, 10}, 0, 0, fmt.Errorf("%w: #%d:%f > #%d:%f", errInvalidPercentile, 0, 20.0000, 1, 10.0000)},
+		{false, 1000, 1000, 1000000000, 30, nil, 0, 31, nil},
+		{false, 1000, 1000, 1000000000, rpc.LatestBlockNumber, nil, 0, 33, nil},
+		{false, 1000, 1000, 10, 40, nil, 0, 0, fmt.Errorf("%w: requested %d, head %d", errRequestBeyondHead, 40, 32)},
+		{true, 1000, 1000, 10, 40, nil, 0, 0, fmt.Errorf("%w: requested %d, head %d", errRequestBeyondHead, 40, 32)},
+		{false, 20, 2, 100, rpc.LatestBlockNumber, nil, 13, 20, nil},
+		{false, 20, 2, 100, rpc.LatestBlockNumber, []float64{0, 10}, 31, 2, nil},
+		{false, 20, 2, 100, 32, []float64{0, 10}, 31, 2, nil},
+		{false, 1000, 1000, 1, rpc.PendingBlockNumber, nil, 0, 0, nil},
+		{false, 1000, 1000, 2, rpc.PendingBlockNumber, nil, 32, 1, nil},
+		{true, 1000, 1000, 2, rpc.PendingBlockNumber, nil, 32, 2, nil},
+		{true, 1000, 1000, 2, rpc.PendingBlockNumber, []float64{0, 10}, 32, 2, nil},
 	}
 	magmaBlock, kaiaBlock := int64(16), int64(20)
-	backend, govModule := newTestBackend(t, big.NewInt(magmaBlock), big.NewInt(kaiaBlock))
-
-	defer backend.teardown()
 	for i, c := range cases {
 		config := Config{
 			MaxHeaderHistory: c.maxHeader,
 			MaxBlockHistory:  c.maxBlock,
 			MaxPrice:         big.NewInt(500000000000),
 		}
+		backend, govModule := newTestBackend(t, big.NewInt(magmaBlock), big.NewInt(kaiaBlock), c.pending)
 		oracle := NewOracle(backend, config, nil, govModule)
 
 		first, reward, baseFee, ratio, err := oracle.FeeHistory(context.Background(), c.count, c.last, c.percent)
@@ -92,7 +94,8 @@ func TestFeeHistory(t *testing.T) {
 			MaxBlockHistory:  1000,
 			MaxPrice:         big.NewInt(500000000000),
 		}
-		oracle = NewOracle(backend, config, nil, govModule)
+		backend, govModule = newTestBackend(t, big.NewInt(magmaBlock), big.NewInt(kaiaBlock), false)
+		oracle             = NewOracle(backend, config, nil, govModule)
 
 		atMagmaPset    = oracle.govModule.GetParamSet(uint64(magmaBlock))
 		afterMagmaPset = oracle.govModule.GetParamSet(uint64(magmaBlock + 1))
diff --git a/node/cn/gasprice/gasprice.go b/node/cn/gasprice/gasprice.go
index b52b47073..db3c54614 100644
--- a/node/cn/gasprice/gasprice.go
+++ b/node/cn/gasprice/gasprice.go
@@ -28,6 +28,7 @@ import (
 	"sync"
 
 	lru "github.com/hashicorp/golang-lru"
+	"github.com/kaiachain/kaia/blockchain/state"
 	"github.com/kaiachain/kaia/blockchain/types"
 	"github.com/kaiachain/kaia/common"
 	"github.com/kaiachain/kaia/consensus/misc"
@@ -42,8 +43,8 @@ const sampleNumber = 3 // Number of transactions sampled in a block
 type Config struct {
 	Blocks           int
 	Percentile       int
-	MaxHeaderHistory int
-	MaxBlockHistory  int
+	MaxHeaderHistory uint64
+	MaxBlockHistory  uint64
 	MaxPrice         *big.Int `toml:",omitempty"`
 }
 
@@ -52,6 +53,7 @@ type OracleBackend interface {
 	HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error)
 	BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error)
 	GetBlockReceipts(ctx context.Context, hash common.Hash) types.Receipts
+	Pending() (*types.Block, types.Receipts, *state.StateDB)
 	ChainConfig() *params.ChainConfig
 	CurrentBlock() *types.Block
 }
@@ -74,7 +76,7 @@ type Oracle struct {
 
 	checkBlocks, maxEmpty, maxBlocks  int
 	percentile                        int
-	maxHeaderHistory, maxBlockHistory int
+	maxHeaderHistory, maxBlockHistory uint64
 
 	historyCache *lru.Cache
 }
@@ -148,17 +150,17 @@ func NewOracle(backend OracleBackend, config Config, txPool TxPool, govModule go
 
 // SuggestPrice returns the recommended gas price.
 // This value is intended to be used as gasPrice or maxFeePerGas.
-func (gpo *Oracle) SuggestPrice(ctx context.Context) (*big.Int, error) {
-	if gpo.txPool == nil {
+func (oracle *Oracle) SuggestPrice(ctx context.Context) (*big.Int, error) {
+	if oracle.txPool == nil {
 		// If txpool is not set, just return 0. This is used for testing.
 		return common.Big0, nil
 	}
 
-	nextNum := new(big.Int).Add(gpo.backend.CurrentBlock().Number(), common.Big1)
-	if gpo.backend.ChainConfig().IsKaiaForkEnabled(nextNum) {
+	nextNum := new(big.Int).Add(oracle.backend.CurrentBlock().Number(), common.Big1)
+	if oracle.backend.ChainConfig().IsKaiaForkEnabled(nextNum) {
 		// After Kaia, include suggested tip
-		baseFee := gpo.txPool.GasPrice()
-		suggestedTip, err := gpo.SuggestTipCap(ctx)
+		baseFee := oracle.txPool.GasPrice()
+		suggestedTip, err := oracle.SuggestTipCap(ctx)
 		if err != nil {
 			return nil, err
 		}
@@ -170,52 +172,52 @@ func (gpo *Oracle) SuggestPrice(ctx context.Context) (*big.Int, error) {
 		}
 		baseFee.Div(baseFee, big.NewInt(100))
 		return new(big.Int).Add(baseFee, suggestedTip), nil
-	} else if gpo.backend.ChainConfig().IsMagmaForkEnabled(nextNum) {
+	} else if oracle.backend.ChainConfig().IsMagmaForkEnabled(nextNum) {
 		// After Magma, return the twice of BaseFee as a buffer.
-		baseFee := gpo.txPool.GasPrice()
+		baseFee := oracle.txPool.GasPrice()
 		return new(big.Int).Mul(baseFee, common.Big2), nil
 	} else {
 		// Before Magma, return the fixed UnitPrice.
-		unitPrice := gpo.txPool.GasPrice()
+		unitPrice := oracle.txPool.GasPrice()
 		return unitPrice, nil
 	}
 }
 
 // SuggestTipCap returns the recommended gas tip cap.
 // This value is intended to be used as maxPriorityFeePerGas.
-func (gpo *Oracle) SuggestTipCap(ctx context.Context) (*big.Int, error) {
-	if gpo.txPool == nil {
+func (oracle *Oracle) SuggestTipCap(ctx context.Context) (*big.Int, error) {
+	if oracle.txPool == nil {
 		// If txpool is not set, just return 0. This is used for testing.
 		return common.Big0, nil
 	}
 
-	nextNum := new(big.Int).Add(gpo.backend.CurrentBlock().Number(), common.Big1)
-	if gpo.backend.ChainConfig().IsKaiaForkEnabled(nextNum) {
+	nextNum := new(big.Int).Add(oracle.backend.CurrentBlock().Number(), common.Big1)
+	if oracle.backend.ChainConfig().IsKaiaForkEnabled(nextNum) {
 		// After Kaia, return using fee history.
 		// If the next baseFee is lower bound, return 0.
 		// Otherwise, by default config, this will return 60% percentile of last 20 blocks.
 		// See node/cn/config.go for the default config.
-		header := gpo.backend.CurrentBlock().Header()
+		header := oracle.backend.CurrentBlock().Header()
 		headHash := header.Hash()
 		// If the latest gasprice is still available, return it.
-		if lastPrice, ok := gpo.readCacheChecked(headHash); ok {
+		if lastPrice, ok := oracle.readCacheChecked(headHash); ok {
 			return new(big.Int).Set(lastPrice), nil
 		}
-		if gpo.isRelaxedNetwork(header) {
-			gpo.writeCache(headHash, common.Big0)
+		if oracle.isRelaxedNetwork(header) {
+			oracle.writeCache(headHash, common.Big0)
 			return common.Big0, nil
 		}
-		price, err := gpo.suggestTipCapUsingFeeHistory(ctx)
+		price, err := oracle.suggestTipCapUsingFeeHistory(ctx)
 		if err == nil {
-			gpo.writeCache(headHash, price)
+			oracle.writeCache(headHash, price)
 		}
 		return price, err
-	} else if gpo.backend.ChainConfig().IsMagmaForkEnabled(nextNum) {
+	} else if oracle.backend.ChainConfig().IsMagmaForkEnabled(nextNum) {
 		// After Magma, return zero
 		return common.Big0, nil
 	} else {
 		// Before Magma, return the fixed UnitPrice.
-		unitPrice := gpo.txPool.GasPrice()
+		unitPrice := oracle.txPool.GasPrice()
 		return unitPrice, nil
 	}
 }
diff --git a/node/cn/gasprice/gasprice_test.go b/node/cn/gasprice/gasprice_test.go
index 5f458e8ae..c11c868a1 100644
--- a/node/cn/gasprice/gasprice_test.go
+++ b/node/cn/gasprice/gasprice_test.go
@@ -26,6 +26,7 @@ import (
 	"github.com/golang/mock/gomock"
 	mock_api "github.com/kaiachain/kaia/api/mocks"
 	"github.com/kaiachain/kaia/blockchain"
+	"github.com/kaiachain/kaia/blockchain/state"
 	"github.com/kaiachain/kaia/blockchain/types"
 	"github.com/kaiachain/kaia/blockchain/vm"
 	"github.com/kaiachain/kaia/common"
@@ -45,7 +46,8 @@ import (
 const testHead = 32
 
 type testBackend struct {
-	chain *blockchain.BlockChain
+	chain   *blockchain.BlockChain
+	pending bool // pending block available
 }
 
 func (b *testBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error) {
@@ -55,6 +57,13 @@ func (b *testBackend) HeaderByNumber(ctx context.Context, number rpc.BlockNumber
 	if number == rpc.LatestBlockNumber {
 		number = testHead
 	}
+	if number == rpc.PendingBlockNumber {
+		if b.pending {
+			number = testHead + 1
+		} else {
+			return nil, nil
+		}
+	}
 	return b.chain.GetHeaderByNumber(uint64(number)), nil
 }
 
@@ -65,6 +74,13 @@ func (b *testBackend) BlockByNumber(ctx context.Context, number rpc.BlockNumber)
 	if number == rpc.LatestBlockNumber {
 		number = testHead
 	}
+	if number == rpc.PendingBlockNumber {
+		if b.pending {
+			number = testHead + 1
+		} else {
+			return nil, nil
+		}
+	}
 	return b.chain.GetBlockByNumber(uint64(number)), nil
 }
 
@@ -72,6 +88,15 @@ func (b *testBackend) GetBlockReceipts(ctx context.Context, hash common.Hash) ty
 	return b.chain.GetReceiptsByBlockHash(hash)
 }
 
+func (b *testBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) {
+	if b.pending {
+		block := b.chain.GetBlockByNumber(testHead + 1)
+		state, _ := b.chain.StateAt(block.Root())
+		return block, b.chain.GetReceiptsByBlockHash(block.Hash()), state
+	}
+	return nil, nil, nil
+}
+
 func (b *testBackend) ChainConfig() *params.ChainConfig {
 	return b.chain.Config()
 }
@@ -86,7 +111,7 @@ func (b *testBackend) teardown() {
 
 // newTestBackend creates a test backend. OBS: don't forget to invoke tearDown
 // after use, otherwise the blockchain instance will mem-leak via goroutines.
-func newTestBackend(t *testing.T, magmaBlock, kaiaBlock *big.Int) (*testBackend, gov.GovModule) {
+func newTestBackend(t *testing.T, magmaBlock, kaiaBlock *big.Int, pending bool) (*testBackend, gov.GovModule) {
 	var (
 		key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		addr   = crypto.PubkeyToAddress(key.PublicKey)
@@ -157,7 +182,7 @@ func newTestBackend(t *testing.T, magmaBlock, kaiaBlock *big.Int) (*testBackend,
 
 	chain.InsertChain(blocks)
 
-	return &testBackend{chain: chain}, govModule
+	return &testBackend{chain: chain, pending: pending}, govModule
 }
 
 func TestGasPrice_NewOracle(t *testing.T) {
@@ -217,7 +242,7 @@ func TestGasPrice_SuggestPrice(t *testing.T) {
 	defer mockCtrl.Finish()
 	mockBackend := mock_api.NewMockBackend(mockCtrl)
 	params := Config{}
-	testBackend, _ := newTestBackend(t, nil, nil)
+	testBackend, _ := newTestBackend(t, nil, nil, false)
 	defer testBackend.teardown()
 	chainConfig := testBackend.ChainConfig()
 	mockGov := mock_gov.NewMockGovModule(gomock.NewController(t))
@@ -284,7 +309,7 @@ func TestSuggestTipCap(t *testing.T) {
 		{big.NewInt(33), big.NewInt(33), big.NewInt(params.Gkei * int64(30)), true}, // Fork point in the future
 	}
 	for _, c := range cases {
-		testBackend, testGov := newTestBackend(t, c.magmaBlock, c.kaiaBlock)
+		testBackend, testGov := newTestBackend(t, c.magmaBlock, c.kaiaBlock, false)
 		chainConfig := testBackend.ChainConfig()
 		if c.isBusy {
 			mockGov := mock_gov.NewMockGovModule(gomock.NewController(t))
diff --git a/node/cn/mocks/fetcher_mock.go b/node/cn/mocks/fetcher_mock.go
index a89d2e39a..71901c2b5 100644
--- a/node/cn/mocks/fetcher_mock.go
+++ b/node/cn/mocks/fetcher_mock.go
@@ -14,30 +14,30 @@ import (
 	fetcher "github.com/kaiachain/kaia/datasync/fetcher"
 )
 
-// MockProtocolManagerFetcher is a mock of ProtocolManagerFetcher interface
+// MockProtocolManagerFetcher is a mock of ProtocolManagerFetcher interface.
 type MockProtocolManagerFetcher struct {
 	ctrl     *gomock.Controller
 	recorder *MockProtocolManagerFetcherMockRecorder
 }
 
-// MockProtocolManagerFetcherMockRecorder is the mock recorder for MockProtocolManagerFetcher
+// MockProtocolManagerFetcherMockRecorder is the mock recorder for MockProtocolManagerFetcher.
 type MockProtocolManagerFetcherMockRecorder struct {
 	mock *MockProtocolManagerFetcher
 }
 
-// NewMockProtocolManagerFetcher creates a new mock instance
+// NewMockProtocolManagerFetcher creates a new mock instance.
 func NewMockProtocolManagerFetcher(ctrl *gomock.Controller) *MockProtocolManagerFetcher {
 	mock := &MockProtocolManagerFetcher{ctrl: ctrl}
 	mock.recorder = &MockProtocolManagerFetcherMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockProtocolManagerFetcher) EXPECT() *MockProtocolManagerFetcherMockRecorder {
 	return m.recorder
 }
 
-// Enqueue mocks base method
+// Enqueue mocks base method.
 func (m *MockProtocolManagerFetcher) Enqueue(arg0 string, arg1 *types.Block) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Enqueue", arg0, arg1)
@@ -45,13 +45,13 @@ func (m *MockProtocolManagerFetcher) Enqueue(arg0 string, arg1 *types.Block) err
 	return ret0
 }
 
-// Enqueue indicates an expected call of Enqueue
+// Enqueue indicates an expected call of Enqueue.
 func (mr *MockProtocolManagerFetcherMockRecorder) Enqueue(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enqueue", reflect.TypeOf((*MockProtocolManagerFetcher)(nil).Enqueue), arg0, arg1)
 }
 
-// FilterBodies mocks base method
+// FilterBodies mocks base method.
 func (m *MockProtocolManagerFetcher) FilterBodies(arg0 string, arg1 [][]*types.Transaction, arg2 time.Time) [][]*types.Transaction {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "FilterBodies", arg0, arg1, arg2)
@@ -59,13 +59,13 @@ func (m *MockProtocolManagerFetcher) FilterBodies(arg0 string, arg1 [][]*types.T
 	return ret0
 }
 
-// FilterBodies indicates an expected call of FilterBodies
+// FilterBodies indicates an expected call of FilterBodies.
 func (mr *MockProtocolManagerFetcherMockRecorder) FilterBodies(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterBodies", reflect.TypeOf((*MockProtocolManagerFetcher)(nil).FilterBodies), arg0, arg1, arg2)
 }
 
-// FilterHeaders mocks base method
+// FilterHeaders mocks base method.
 func (m *MockProtocolManagerFetcher) FilterHeaders(arg0 string, arg1 []*types.Header, arg2 time.Time) []*types.Header {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "FilterHeaders", arg0, arg1, arg2)
@@ -73,13 +73,13 @@ func (m *MockProtocolManagerFetcher) FilterHeaders(arg0 string, arg1 []*types.He
 	return ret0
 }
 
-// FilterHeaders indicates an expected call of FilterHeaders
+// FilterHeaders indicates an expected call of FilterHeaders.
 func (mr *MockProtocolManagerFetcherMockRecorder) FilterHeaders(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterHeaders", reflect.TypeOf((*MockProtocolManagerFetcher)(nil).FilterHeaders), arg0, arg1, arg2)
 }
 
-// Notify mocks base method
+// Notify mocks base method.
 func (m *MockProtocolManagerFetcher) Notify(arg0 string, arg1 common.Hash, arg2 uint64, arg3 time.Time, arg4 fetcher.HeaderRequesterFn, arg5 fetcher.BodyRequesterFn) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Notify", arg0, arg1, arg2, arg3, arg4, arg5)
@@ -87,31 +87,31 @@ func (m *MockProtocolManagerFetcher) Notify(arg0 string, arg1 common.Hash, arg2
 	return ret0
 }
 
-// Notify indicates an expected call of Notify
+// Notify indicates an expected call of Notify.
 func (mr *MockProtocolManagerFetcherMockRecorder) Notify(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notify", reflect.TypeOf((*MockProtocolManagerFetcher)(nil).Notify), arg0, arg1, arg2, arg3, arg4, arg5)
 }
 
-// Start mocks base method
+// Start mocks base method.
 func (m *MockProtocolManagerFetcher) Start() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Start")
 }
 
-// Start indicates an expected call of Start
+// Start indicates an expected call of Start.
 func (mr *MockProtocolManagerFetcherMockRecorder) Start() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockProtocolManagerFetcher)(nil).Start))
 }
 
-// Stop mocks base method
+// Stop mocks base method.
 func (m *MockProtocolManagerFetcher) Stop() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Stop")
 }
 
-// Stop indicates an expected call of Stop
+// Stop indicates an expected call of Stop.
 func (mr *MockProtocolManagerFetcherMockRecorder) Stop() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockProtocolManagerFetcher)(nil).Stop))
diff --git a/node/cn/mocks/miner_mock.go b/node/cn/mocks/miner_mock.go
index 3a0ce7d7e..a885b3c14 100644
--- a/node/cn/mocks/miner_mock.go
+++ b/node/cn/mocks/miner_mock.go
@@ -66,12 +66,13 @@ func (mr *MockMinerMockRecorder) Mining() *gomock.Call {
 }
 
 // Pending mocks base method.
-func (m *MockMiner) Pending() (*types.Block, *state.StateDB) {
+func (m *MockMiner) Pending() (*types.Block, types.Receipts, *state.StateDB) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Pending")
 	ret0, _ := ret[0].(*types.Block)
-	ret1, _ := ret[1].(*state.StateDB)
-	return ret0, ret1
+	ret1, _ := ret[1].(types.Receipts)
+	ret2, _ := ret[2].(*state.StateDB)
+	return ret0, ret1, ret2
 }
 
 // Pending indicates an expected call of Pending.
diff --git a/node/cn/peer_mock_test.go b/node/cn/peer_mock_test.go
index c575ad0ce..007fd4758 100644
--- a/node/cn/peer_mock_test.go
+++ b/node/cn/peer_mock_test.go
@@ -17,126 +17,126 @@ import (
 	rlp "github.com/kaiachain/kaia/rlp"
 )
 
-// MockPeer is a mock of Peer interface
+// MockPeer is a mock of Peer interface.
 type MockPeer struct {
 	ctrl     *gomock.Controller
 	recorder *MockPeerMockRecorder
 }
 
-// MockPeerMockRecorder is the mock recorder for MockPeer
+// MockPeerMockRecorder is the mock recorder for MockPeer.
 type MockPeerMockRecorder struct {
 	mock *MockPeer
 }
 
-// NewMockPeer creates a new mock instance
+// NewMockPeer creates a new mock instance.
 func NewMockPeer(ctrl *gomock.Controller) *MockPeer {
 	mock := &MockPeer{ctrl: ctrl}
 	mock.recorder = &MockPeerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockPeer) EXPECT() *MockPeerMockRecorder {
 	return m.recorder
 }
 
-// AddSnapExtension mocks base method
+// AddSnapExtension mocks base method.
 func (m *MockPeer) AddSnapExtension(arg0 *snap.Peer) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AddSnapExtension", arg0)
 }
 
-// AddSnapExtension indicates an expected call of AddSnapExtension
+// AddSnapExtension indicates an expected call of AddSnapExtension.
 func (mr *MockPeerMockRecorder) AddSnapExtension(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSnapExtension", reflect.TypeOf((*MockPeer)(nil).AddSnapExtension), arg0)
 }
 
-// AddToKnownBlocks mocks base method
+// AddToKnownBlocks mocks base method.
 func (m *MockPeer) AddToKnownBlocks(arg0 common.Hash) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AddToKnownBlocks", arg0)
 }
 
-// AddToKnownBlocks indicates an expected call of AddToKnownBlocks
+// AddToKnownBlocks indicates an expected call of AddToKnownBlocks.
 func (mr *MockPeerMockRecorder) AddToKnownBlocks(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddToKnownBlocks", reflect.TypeOf((*MockPeer)(nil).AddToKnownBlocks), arg0)
 }
 
-// AddToKnownTxs mocks base method
+// AddToKnownTxs mocks base method.
 func (m *MockPeer) AddToKnownTxs(arg0 common.Hash) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AddToKnownTxs", arg0)
 }
 
-// AddToKnownTxs indicates an expected call of AddToKnownTxs
+// AddToKnownTxs indicates an expected call of AddToKnownTxs.
 func (mr *MockPeerMockRecorder) AddToKnownTxs(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddToKnownTxs", reflect.TypeOf((*MockPeer)(nil).AddToKnownTxs), arg0)
 }
 
-// AsyncSendNewBlock mocks base method
+// AsyncSendNewBlock mocks base method.
 func (m *MockPeer) AsyncSendNewBlock(arg0 *types.Block, arg1 *big.Int) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AsyncSendNewBlock", arg0, arg1)
 }
 
-// AsyncSendNewBlock indicates an expected call of AsyncSendNewBlock
+// AsyncSendNewBlock indicates an expected call of AsyncSendNewBlock.
 func (mr *MockPeerMockRecorder) AsyncSendNewBlock(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsyncSendNewBlock", reflect.TypeOf((*MockPeer)(nil).AsyncSendNewBlock), arg0, arg1)
 }
 
-// AsyncSendNewBlockHash mocks base method
+// AsyncSendNewBlockHash mocks base method.
 func (m *MockPeer) AsyncSendNewBlockHash(arg0 *types.Block) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AsyncSendNewBlockHash", arg0)
 }
 
-// AsyncSendNewBlockHash indicates an expected call of AsyncSendNewBlockHash
+// AsyncSendNewBlockHash indicates an expected call of AsyncSendNewBlockHash.
 func (mr *MockPeerMockRecorder) AsyncSendNewBlockHash(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsyncSendNewBlockHash", reflect.TypeOf((*MockPeer)(nil).AsyncSendNewBlockHash), arg0)
 }
 
-// AsyncSendTransactions mocks base method
+// AsyncSendTransactions mocks base method.
 func (m *MockPeer) AsyncSendTransactions(arg0 types.Transactions) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AsyncSendTransactions", arg0)
 }
 
-// AsyncSendTransactions indicates an expected call of AsyncSendTransactions
+// AsyncSendTransactions indicates an expected call of AsyncSendTransactions.
 func (mr *MockPeerMockRecorder) AsyncSendTransactions(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsyncSendTransactions", reflect.TypeOf((*MockPeer)(nil).AsyncSendTransactions), arg0)
 }
 
-// Broadcast mocks base method
+// Broadcast mocks base method.
 func (m *MockPeer) Broadcast() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Broadcast")
 }
 
-// Broadcast indicates an expected call of Broadcast
+// Broadcast indicates an expected call of Broadcast.
 func (mr *MockPeerMockRecorder) Broadcast() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockPeer)(nil).Broadcast))
 }
 
-// Close mocks base method
+// Close mocks base method.
 func (m *MockPeer) Close() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Close")
 }
 
-// Close indicates an expected call of Close
+// Close indicates an expected call of Close.
 func (mr *MockPeerMockRecorder) Close() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPeer)(nil).Close))
 }
 
-// ConnType mocks base method
+// ConnType mocks base method.
 func (m *MockPeer) ConnType() common.ConnType {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ConnType")
@@ -144,25 +144,25 @@ func (m *MockPeer) ConnType() common.ConnType {
 	return ret0
 }
 
-// ConnType indicates an expected call of ConnType
+// ConnType indicates an expected call of ConnType.
 func (mr *MockPeerMockRecorder) ConnType() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnType", reflect.TypeOf((*MockPeer)(nil).ConnType))
 }
 
-// DisconnectP2PPeer mocks base method
+// DisconnectP2PPeer mocks base method.
 func (m *MockPeer) DisconnectP2PPeer(arg0 p2p.DiscReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DisconnectP2PPeer", arg0)
 }
 
-// DisconnectP2PPeer indicates an expected call of DisconnectP2PPeer
+// DisconnectP2PPeer indicates an expected call of DisconnectP2PPeer.
 func (mr *MockPeerMockRecorder) DisconnectP2PPeer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisconnectP2PPeer", reflect.TypeOf((*MockPeer)(nil).DisconnectP2PPeer), arg0)
 }
 
-// ExistSnapExtension mocks base method
+// ExistSnapExtension mocks base method.
 func (m *MockPeer) ExistSnapExtension() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ExistSnapExtension")
@@ -170,13 +170,13 @@ func (m *MockPeer) ExistSnapExtension() bool {
 	return ret0
 }
 
-// ExistSnapExtension indicates an expected call of ExistSnapExtension
+// ExistSnapExtension indicates an expected call of ExistSnapExtension.
 func (mr *MockPeerMockRecorder) ExistSnapExtension() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistSnapExtension", reflect.TypeOf((*MockPeer)(nil).ExistSnapExtension))
 }
 
-// FetchBlockBodies mocks base method
+// FetchBlockBodies mocks base method.
 func (m *MockPeer) FetchBlockBodies(arg0 []common.Hash) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "FetchBlockBodies", arg0)
@@ -184,13 +184,13 @@ func (m *MockPeer) FetchBlockBodies(arg0 []common.Hash) error {
 	return ret0
 }
 
-// FetchBlockBodies indicates an expected call of FetchBlockBodies
+// FetchBlockBodies indicates an expected call of FetchBlockBodies.
 func (mr *MockPeerMockRecorder) FetchBlockBodies(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlockBodies", reflect.TypeOf((*MockPeer)(nil).FetchBlockBodies), arg0)
 }
 
-// FetchBlockHeader mocks base method
+// FetchBlockHeader mocks base method.
 func (m *MockPeer) FetchBlockHeader(arg0 common.Hash) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "FetchBlockHeader", arg0)
@@ -198,13 +198,13 @@ func (m *MockPeer) FetchBlockHeader(arg0 common.Hash) error {
 	return ret0
 }
 
-// FetchBlockHeader indicates an expected call of FetchBlockHeader
+// FetchBlockHeader indicates an expected call of FetchBlockHeader.
 func (mr *MockPeerMockRecorder) FetchBlockHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlockHeader", reflect.TypeOf((*MockPeer)(nil).FetchBlockHeader), arg0)
 }
 
-// GetAddr mocks base method
+// GetAddr mocks base method.
 func (m *MockPeer) GetAddr() common.Address {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAddr")
@@ -212,13 +212,13 @@ func (m *MockPeer) GetAddr() common.Address {
 	return ret0
 }
 
-// GetAddr indicates an expected call of GetAddr
+// GetAddr indicates an expected call of GetAddr.
 func (mr *MockPeerMockRecorder) GetAddr() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddr", reflect.TypeOf((*MockPeer)(nil).GetAddr))
 }
 
-// GetChainID mocks base method
+// GetChainID mocks base method.
 func (m *MockPeer) GetChainID() *big.Int {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetChainID")
@@ -226,13 +226,13 @@ func (m *MockPeer) GetChainID() *big.Int {
 	return ret0
 }
 
-// GetChainID indicates an expected call of GetChainID
+// GetChainID indicates an expected call of GetChainID.
 func (mr *MockPeerMockRecorder) GetChainID() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChainID", reflect.TypeOf((*MockPeer)(nil).GetChainID))
 }
 
-// GetID mocks base method
+// GetID mocks base method.
 func (m *MockPeer) GetID() string {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetID")
@@ -240,13 +240,13 @@ func (m *MockPeer) GetID() string {
 	return ret0
 }
 
-// GetID indicates an expected call of GetID
+// GetID indicates an expected call of GetID.
 func (mr *MockPeerMockRecorder) GetID() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetID", reflect.TypeOf((*MockPeer)(nil).GetID))
 }
 
-// GetP2PPeer mocks base method
+// GetP2PPeer mocks base method.
 func (m *MockPeer) GetP2PPeer() *p2p.Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetP2PPeer")
@@ -254,13 +254,13 @@ func (m *MockPeer) GetP2PPeer() *p2p.Peer {
 	return ret0
 }
 
-// GetP2PPeer indicates an expected call of GetP2PPeer
+// GetP2PPeer indicates an expected call of GetP2PPeer.
 func (mr *MockPeerMockRecorder) GetP2PPeer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetP2PPeer", reflect.TypeOf((*MockPeer)(nil).GetP2PPeer))
 }
 
-// GetP2PPeerID mocks base method
+// GetP2PPeerID mocks base method.
 func (m *MockPeer) GetP2PPeerID() discover.NodeID {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetP2PPeerID")
@@ -268,13 +268,13 @@ func (m *MockPeer) GetP2PPeerID() discover.NodeID {
 	return ret0
 }
 
-// GetP2PPeerID indicates an expected call of GetP2PPeerID
+// GetP2PPeerID indicates an expected call of GetP2PPeerID.
 func (mr *MockPeerMockRecorder) GetP2PPeerID() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetP2PPeerID", reflect.TypeOf((*MockPeer)(nil).GetP2PPeerID))
 }
 
-// GetRW mocks base method
+// GetRW mocks base method.
 func (m *MockPeer) GetRW() p2p.MsgReadWriter {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetRW")
@@ -282,13 +282,13 @@ func (m *MockPeer) GetRW() p2p.MsgReadWriter {
 	return ret0
 }
 
-// GetRW indicates an expected call of GetRW
+// GetRW indicates an expected call of GetRW.
 func (mr *MockPeerMockRecorder) GetRW() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRW", reflect.TypeOf((*MockPeer)(nil).GetRW))
 }
 
-// GetVersion mocks base method
+// GetVersion mocks base method.
 func (m *MockPeer) GetVersion() int {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetVersion")
@@ -296,13 +296,13 @@ func (m *MockPeer) GetVersion() int {
 	return ret0
 }
 
-// GetVersion indicates an expected call of GetVersion
+// GetVersion indicates an expected call of GetVersion.
 func (mr *MockPeerMockRecorder) GetVersion() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersion", reflect.TypeOf((*MockPeer)(nil).GetVersion))
 }
 
-// Handle mocks base method
+// Handle mocks base method.
 func (m *MockPeer) Handle(arg0 *ProtocolManager) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Handle", arg0)
@@ -310,13 +310,13 @@ func (m *MockPeer) Handle(arg0 *ProtocolManager) error {
 	return ret0
 }
 
-// Handle indicates an expected call of Handle
+// Handle indicates an expected call of Handle.
 func (mr *MockPeerMockRecorder) Handle(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handle", reflect.TypeOf((*MockPeer)(nil).Handle), arg0)
 }
 
-// Handshake mocks base method
+// Handshake mocks base method.
 func (m *MockPeer) Handshake(arg0 uint64, arg1, arg2 *big.Int, arg3, arg4 common.Hash) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Handshake", arg0, arg1, arg2, arg3, arg4)
@@ -324,13 +324,13 @@ func (m *MockPeer) Handshake(arg0 uint64, arg1, arg2 *big.Int, arg3, arg4 common
 	return ret0
 }
 
-// Handshake indicates an expected call of Handshake
+// Handshake indicates an expected call of Handshake.
 func (mr *MockPeerMockRecorder) Handshake(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Handshake", reflect.TypeOf((*MockPeer)(nil).Handshake), arg0, arg1, arg2, arg3, arg4)
 }
 
-// Head mocks base method
+// Head mocks base method.
 func (m *MockPeer) Head() (common.Hash, *big.Int) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Head")
@@ -339,13 +339,13 @@ func (m *MockPeer) Head() (common.Hash, *big.Int) {
 	return ret0, ret1
 }
 
-// Head indicates an expected call of Head
+// Head indicates an expected call of Head.
 func (mr *MockPeerMockRecorder) Head() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockPeer)(nil).Head))
 }
 
-// Info mocks base method
+// Info mocks base method.
 func (m *MockPeer) Info() *PeerInfo {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Info")
@@ -353,13 +353,13 @@ func (m *MockPeer) Info() *PeerInfo {
 	return ret0
 }
 
-// Info indicates an expected call of Info
+// Info indicates an expected call of Info.
 func (mr *MockPeerMockRecorder) Info() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockPeer)(nil).Info))
 }
 
-// KnowsBlock mocks base method
+// KnowsBlock mocks base method.
 func (m *MockPeer) KnowsBlock(arg0 common.Hash) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "KnowsBlock", arg0)
@@ -367,13 +367,13 @@ func (m *MockPeer) KnowsBlock(arg0 common.Hash) bool {
 	return ret0
 }
 
-// KnowsBlock indicates an expected call of KnowsBlock
+// KnowsBlock indicates an expected call of KnowsBlock.
 func (mr *MockPeerMockRecorder) KnowsBlock(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KnowsBlock", reflect.TypeOf((*MockPeer)(nil).KnowsBlock), arg0)
 }
 
-// KnowsTx mocks base method
+// KnowsTx mocks base method.
 func (m *MockPeer) KnowsTx(arg0 common.Hash) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "KnowsTx", arg0)
@@ -381,13 +381,13 @@ func (m *MockPeer) KnowsTx(arg0 common.Hash) bool {
 	return ret0
 }
 
-// KnowsTx indicates an expected call of KnowsTx
+// KnowsTx indicates an expected call of KnowsTx.
 func (mr *MockPeerMockRecorder) KnowsTx(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KnowsTx", reflect.TypeOf((*MockPeer)(nil).KnowsTx), arg0)
 }
 
-// ReSendTransactions mocks base method
+// ReSendTransactions mocks base method.
 func (m *MockPeer) ReSendTransactions(arg0 types.Transactions) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ReSendTransactions", arg0)
@@ -395,13 +395,13 @@ func (m *MockPeer) ReSendTransactions(arg0 types.Transactions) error {
 	return ret0
 }
 
-// ReSendTransactions indicates an expected call of ReSendTransactions
+// ReSendTransactions indicates an expected call of ReSendTransactions.
 func (mr *MockPeerMockRecorder) ReSendTransactions(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReSendTransactions", reflect.TypeOf((*MockPeer)(nil).ReSendTransactions), arg0)
 }
 
-// RegisterConsensusMsgCode mocks base method
+// RegisterConsensusMsgCode mocks base method.
 func (m *MockPeer) RegisterConsensusMsgCode(arg0 uint64) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RegisterConsensusMsgCode", arg0)
@@ -409,13 +409,13 @@ func (m *MockPeer) RegisterConsensusMsgCode(arg0 uint64) error {
 	return ret0
 }
 
-// RegisterConsensusMsgCode indicates an expected call of RegisterConsensusMsgCode
+// RegisterConsensusMsgCode indicates an expected call of RegisterConsensusMsgCode.
 func (mr *MockPeerMockRecorder) RegisterConsensusMsgCode(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterConsensusMsgCode", reflect.TypeOf((*MockPeer)(nil).RegisterConsensusMsgCode), arg0)
 }
 
-// RequestBodies mocks base method
+// RequestBodies mocks base method.
 func (m *MockPeer) RequestBodies(arg0 []common.Hash) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RequestBodies", arg0)
@@ -423,13 +423,13 @@ func (m *MockPeer) RequestBodies(arg0 []common.Hash) error {
 	return ret0
 }
 
-// RequestBodies indicates an expected call of RequestBodies
+// RequestBodies indicates an expected call of RequestBodies.
 func (mr *MockPeerMockRecorder) RequestBodies(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestBodies", reflect.TypeOf((*MockPeer)(nil).RequestBodies), arg0)
 }
 
-// RequestHeadersByHash mocks base method
+// RequestHeadersByHash mocks base method.
 func (m *MockPeer) RequestHeadersByHash(arg0 common.Hash, arg1, arg2 int, arg3 bool) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RequestHeadersByHash", arg0, arg1, arg2, arg3)
@@ -437,13 +437,13 @@ func (m *MockPeer) RequestHeadersByHash(arg0 common.Hash, arg1, arg2 int, arg3 b
 	return ret0
 }
 
-// RequestHeadersByHash indicates an expected call of RequestHeadersByHash
+// RequestHeadersByHash indicates an expected call of RequestHeadersByHash.
 func (mr *MockPeerMockRecorder) RequestHeadersByHash(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestHeadersByHash", reflect.TypeOf((*MockPeer)(nil).RequestHeadersByHash), arg0, arg1, arg2, arg3)
 }
 
-// RequestHeadersByNumber mocks base method
+// RequestHeadersByNumber mocks base method.
 func (m *MockPeer) RequestHeadersByNumber(arg0 uint64, arg1, arg2 int, arg3 bool) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RequestHeadersByNumber", arg0, arg1, arg2, arg3)
@@ -451,13 +451,13 @@ func (m *MockPeer) RequestHeadersByNumber(arg0 uint64, arg1, arg2 int, arg3 bool
 	return ret0
 }
 
-// RequestHeadersByNumber indicates an expected call of RequestHeadersByNumber
+// RequestHeadersByNumber indicates an expected call of RequestHeadersByNumber.
 func (mr *MockPeerMockRecorder) RequestHeadersByNumber(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestHeadersByNumber", reflect.TypeOf((*MockPeer)(nil).RequestHeadersByNumber), arg0, arg1, arg2, arg3)
 }
 
-// RequestNodeData mocks base method
+// RequestNodeData mocks base method.
 func (m *MockPeer) RequestNodeData(arg0 []common.Hash) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RequestNodeData", arg0)
@@ -465,13 +465,13 @@ func (m *MockPeer) RequestNodeData(arg0 []common.Hash) error {
 	return ret0
 }
 
-// RequestNodeData indicates an expected call of RequestNodeData
+// RequestNodeData indicates an expected call of RequestNodeData.
 func (mr *MockPeerMockRecorder) RequestNodeData(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestNodeData", reflect.TypeOf((*MockPeer)(nil).RequestNodeData), arg0)
 }
 
-// RequestReceipts mocks base method
+// RequestReceipts mocks base method.
 func (m *MockPeer) RequestReceipts(arg0 []common.Hash) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RequestReceipts", arg0)
@@ -479,13 +479,13 @@ func (m *MockPeer) RequestReceipts(arg0 []common.Hash) error {
 	return ret0
 }
 
-// RequestReceipts indicates an expected call of RequestReceipts
+// RequestReceipts indicates an expected call of RequestReceipts.
 func (mr *MockPeerMockRecorder) RequestReceipts(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestReceipts", reflect.TypeOf((*MockPeer)(nil).RequestReceipts), arg0)
 }
 
-// RequestStakingInfo mocks base method
+// RequestStakingInfo mocks base method.
 func (m *MockPeer) RequestStakingInfo(arg0 []common.Hash) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RequestStakingInfo", arg0)
@@ -493,13 +493,13 @@ func (m *MockPeer) RequestStakingInfo(arg0 []common.Hash) error {
 	return ret0
 }
 
-// RequestStakingInfo indicates an expected call of RequestStakingInfo
+// RequestStakingInfo indicates an expected call of RequestStakingInfo.
 func (mr *MockPeerMockRecorder) RequestStakingInfo(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestStakingInfo", reflect.TypeOf((*MockPeer)(nil).RequestStakingInfo), arg0)
 }
 
-// RunningCap mocks base method
+// RunningCap mocks base method.
 func (m *MockPeer) RunningCap(arg0 string, arg1 []uint) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RunningCap", arg0, arg1)
@@ -507,13 +507,13 @@ func (m *MockPeer) RunningCap(arg0 string, arg1 []uint) bool {
 	return ret0
 }
 
-// RunningCap indicates an expected call of RunningCap
+// RunningCap indicates an expected call of RunningCap.
 func (mr *MockPeerMockRecorder) RunningCap(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunningCap", reflect.TypeOf((*MockPeer)(nil).RunningCap), arg0, arg1)
 }
 
-// Send mocks base method
+// Send mocks base method.
 func (m *MockPeer) Send(arg0 uint64, arg1 interface{}) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Send", arg0, arg1)
@@ -521,13 +521,13 @@ func (m *MockPeer) Send(arg0 uint64, arg1 interface{}) error {
 	return ret0
 }
 
-// Send indicates an expected call of Send
+// Send indicates an expected call of Send.
 func (mr *MockPeerMockRecorder) Send(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockPeer)(nil).Send), arg0, arg1)
 }
 
-// SendBlockBodies mocks base method
+// SendBlockBodies mocks base method.
 func (m *MockPeer) SendBlockBodies(arg0 []*blockBody) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendBlockBodies", arg0)
@@ -535,13 +535,13 @@ func (m *MockPeer) SendBlockBodies(arg0 []*blockBody) error {
 	return ret0
 }
 
-// SendBlockBodies indicates an expected call of SendBlockBodies
+// SendBlockBodies indicates an expected call of SendBlockBodies.
 func (mr *MockPeerMockRecorder) SendBlockBodies(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendBlockBodies", reflect.TypeOf((*MockPeer)(nil).SendBlockBodies), arg0)
 }
 
-// SendBlockBodiesRLP mocks base method
+// SendBlockBodiesRLP mocks base method.
 func (m *MockPeer) SendBlockBodiesRLP(arg0 []rlp.RawValue) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendBlockBodiesRLP", arg0)
@@ -549,13 +549,13 @@ func (m *MockPeer) SendBlockBodiesRLP(arg0 []rlp.RawValue) error {
 	return ret0
 }
 
-// SendBlockBodiesRLP indicates an expected call of SendBlockBodiesRLP
+// SendBlockBodiesRLP indicates an expected call of SendBlockBodiesRLP.
 func (mr *MockPeerMockRecorder) SendBlockBodiesRLP(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendBlockBodiesRLP", reflect.TypeOf((*MockPeer)(nil).SendBlockBodiesRLP), arg0)
 }
 
-// SendBlockHeaders mocks base method
+// SendBlockHeaders mocks base method.
 func (m *MockPeer) SendBlockHeaders(arg0 []*types.Header) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendBlockHeaders", arg0)
@@ -563,13 +563,13 @@ func (m *MockPeer) SendBlockHeaders(arg0 []*types.Header) error {
 	return ret0
 }
 
-// SendBlockHeaders indicates an expected call of SendBlockHeaders
+// SendBlockHeaders indicates an expected call of SendBlockHeaders.
 func (mr *MockPeerMockRecorder) SendBlockHeaders(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendBlockHeaders", reflect.TypeOf((*MockPeer)(nil).SendBlockHeaders), arg0)
 }
 
-// SendFetchedBlockBodiesRLP mocks base method
+// SendFetchedBlockBodiesRLP mocks base method.
 func (m *MockPeer) SendFetchedBlockBodiesRLP(arg0 []rlp.RawValue) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendFetchedBlockBodiesRLP", arg0)
@@ -577,13 +577,13 @@ func (m *MockPeer) SendFetchedBlockBodiesRLP(arg0 []rlp.RawValue) error {
 	return ret0
 }
 
-// SendFetchedBlockBodiesRLP indicates an expected call of SendFetchedBlockBodiesRLP
+// SendFetchedBlockBodiesRLP indicates an expected call of SendFetchedBlockBodiesRLP.
 func (mr *MockPeerMockRecorder) SendFetchedBlockBodiesRLP(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendFetchedBlockBodiesRLP", reflect.TypeOf((*MockPeer)(nil).SendFetchedBlockBodiesRLP), arg0)
 }
 
-// SendFetchedBlockHeader mocks base method
+// SendFetchedBlockHeader mocks base method.
 func (m *MockPeer) SendFetchedBlockHeader(arg0 *types.Header) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendFetchedBlockHeader", arg0)
@@ -591,13 +591,13 @@ func (m *MockPeer) SendFetchedBlockHeader(arg0 *types.Header) error {
 	return ret0
 }
 
-// SendFetchedBlockHeader indicates an expected call of SendFetchedBlockHeader
+// SendFetchedBlockHeader indicates an expected call of SendFetchedBlockHeader.
 func (mr *MockPeerMockRecorder) SendFetchedBlockHeader(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendFetchedBlockHeader", reflect.TypeOf((*MockPeer)(nil).SendFetchedBlockHeader), arg0)
 }
 
-// SendNewBlock mocks base method
+// SendNewBlock mocks base method.
 func (m *MockPeer) SendNewBlock(arg0 *types.Block, arg1 *big.Int) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendNewBlock", arg0, arg1)
@@ -605,13 +605,13 @@ func (m *MockPeer) SendNewBlock(arg0 *types.Block, arg1 *big.Int) error {
 	return ret0
 }
 
-// SendNewBlock indicates an expected call of SendNewBlock
+// SendNewBlock indicates an expected call of SendNewBlock.
 func (mr *MockPeerMockRecorder) SendNewBlock(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendNewBlock", reflect.TypeOf((*MockPeer)(nil).SendNewBlock), arg0, arg1)
 }
 
-// SendNewBlockHashes mocks base method
+// SendNewBlockHashes mocks base method.
 func (m *MockPeer) SendNewBlockHashes(arg0 []common.Hash, arg1 []uint64) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendNewBlockHashes", arg0, arg1)
@@ -619,13 +619,13 @@ func (m *MockPeer) SendNewBlockHashes(arg0 []common.Hash, arg1 []uint64) error {
 	return ret0
 }
 
-// SendNewBlockHashes indicates an expected call of SendNewBlockHashes
+// SendNewBlockHashes indicates an expected call of SendNewBlockHashes.
 func (mr *MockPeerMockRecorder) SendNewBlockHashes(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendNewBlockHashes", reflect.TypeOf((*MockPeer)(nil).SendNewBlockHashes), arg0, arg1)
 }
 
-// SendNodeData mocks base method
+// SendNodeData mocks base method.
 func (m *MockPeer) SendNodeData(arg0 [][]byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendNodeData", arg0)
@@ -633,13 +633,13 @@ func (m *MockPeer) SendNodeData(arg0 [][]byte) error {
 	return ret0
 }
 
-// SendNodeData indicates an expected call of SendNodeData
+// SendNodeData indicates an expected call of SendNodeData.
 func (mr *MockPeerMockRecorder) SendNodeData(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendNodeData", reflect.TypeOf((*MockPeer)(nil).SendNodeData), arg0)
 }
 
-// SendReceiptsRLP mocks base method
+// SendReceiptsRLP mocks base method.
 func (m *MockPeer) SendReceiptsRLP(arg0 []rlp.RawValue) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendReceiptsRLP", arg0)
@@ -647,13 +647,13 @@ func (m *MockPeer) SendReceiptsRLP(arg0 []rlp.RawValue) error {
 	return ret0
 }
 
-// SendReceiptsRLP indicates an expected call of SendReceiptsRLP
+// SendReceiptsRLP indicates an expected call of SendReceiptsRLP.
 func (mr *MockPeerMockRecorder) SendReceiptsRLP(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendReceiptsRLP", reflect.TypeOf((*MockPeer)(nil).SendReceiptsRLP), arg0)
 }
 
-// SendStakingInfoRLP mocks base method
+// SendStakingInfoRLP mocks base method.
 func (m *MockPeer) SendStakingInfoRLP(arg0 []rlp.RawValue) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendStakingInfoRLP", arg0)
@@ -661,13 +661,13 @@ func (m *MockPeer) SendStakingInfoRLP(arg0 []rlp.RawValue) error {
 	return ret0
 }
 
-// SendStakingInfoRLP indicates an expected call of SendStakingInfoRLP
+// SendStakingInfoRLP indicates an expected call of SendStakingInfoRLP.
 func (mr *MockPeerMockRecorder) SendStakingInfoRLP(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendStakingInfoRLP", reflect.TypeOf((*MockPeer)(nil).SendStakingInfoRLP), arg0)
 }
 
-// SendTransactions mocks base method
+// SendTransactions mocks base method.
 func (m *MockPeer) SendTransactions(arg0 types.Transactions) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendTransactions", arg0)
@@ -675,43 +675,43 @@ func (m *MockPeer) SendTransactions(arg0 types.Transactions) error {
 	return ret0
 }
 
-// SendTransactions indicates an expected call of SendTransactions
+// SendTransactions indicates an expected call of SendTransactions.
 func (mr *MockPeerMockRecorder) SendTransactions(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTransactions", reflect.TypeOf((*MockPeer)(nil).SendTransactions), arg0)
 }
 
-// SetAddr mocks base method
+// SetAddr mocks base method.
 func (m *MockPeer) SetAddr(arg0 common.Address) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetAddr", arg0)
 }
 
-// SetAddr indicates an expected call of SetAddr
+// SetAddr indicates an expected call of SetAddr.
 func (mr *MockPeerMockRecorder) SetAddr(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddr", reflect.TypeOf((*MockPeer)(nil).SetAddr), arg0)
 }
 
-// SetHead mocks base method
+// SetHead mocks base method.
 func (m *MockPeer) SetHead(arg0 common.Hash, arg1 *big.Int) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetHead", arg0, arg1)
 }
 
-// SetHead indicates an expected call of SetHead
+// SetHead indicates an expected call of SetHead.
 func (mr *MockPeerMockRecorder) SetHead(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHead", reflect.TypeOf((*MockPeer)(nil).SetHead), arg0, arg1)
 }
 
-// UpdateRWImplementationVersion mocks base method
+// UpdateRWImplementationVersion mocks base method.
 func (m *MockPeer) UpdateRWImplementationVersion() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdateRWImplementationVersion")
 }
 
-// UpdateRWImplementationVersion indicates an expected call of UpdateRWImplementationVersion
+// UpdateRWImplementationVersion indicates an expected call of UpdateRWImplementationVersion.
 func (mr *MockPeerMockRecorder) UpdateRWImplementationVersion() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRWImplementationVersion", reflect.TypeOf((*MockPeer)(nil).UpdateRWImplementationVersion))
diff --git a/node/cn/peer_set_mock_test.go b/node/cn/peer_set_mock_test.go
index b827a9bb3..01adc121f 100644
--- a/node/cn/peer_set_mock_test.go
+++ b/node/cn/peer_set_mock_test.go
@@ -14,30 +14,30 @@ import (
 	snap "github.com/kaiachain/kaia/node/cn/snap"
 )
 
-// MockPeerSet is a mock of PeerSet interface
+// MockPeerSet is a mock of PeerSet interface.
 type MockPeerSet struct {
 	ctrl     *gomock.Controller
 	recorder *MockPeerSetMockRecorder
 }
 
-// MockPeerSetMockRecorder is the mock recorder for MockPeerSet
+// MockPeerSetMockRecorder is the mock recorder for MockPeerSet.
 type MockPeerSetMockRecorder struct {
 	mock *MockPeerSet
 }
 
-// NewMockPeerSet creates a new mock instance
+// NewMockPeerSet creates a new mock instance.
 func NewMockPeerSet(ctrl *gomock.Controller) *MockPeerSet {
 	mock := &MockPeerSet{ctrl: ctrl}
 	mock.recorder = &MockPeerSetMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockPeerSet) EXPECT() *MockPeerSetMockRecorder {
 	return m.recorder
 }
 
-// BestPeer mocks base method
+// BestPeer mocks base method.
 func (m *MockPeerSet) BestPeer() Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "BestPeer")
@@ -45,13 +45,13 @@ func (m *MockPeerSet) BestPeer() Peer {
 	return ret0
 }
 
-// BestPeer indicates an expected call of BestPeer
+// BestPeer indicates an expected call of BestPeer.
 func (mr *MockPeerSetMockRecorder) BestPeer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BestPeer", reflect.TypeOf((*MockPeerSet)(nil).BestPeer))
 }
 
-// CNPeers mocks base method
+// CNPeers mocks base method.
 func (m *MockPeerSet) CNPeers() map[common.Address]Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CNPeers")
@@ -59,13 +59,13 @@ func (m *MockPeerSet) CNPeers() map[common.Address]Peer {
 	return ret0
 }
 
-// CNPeers indicates an expected call of CNPeers
+// CNPeers indicates an expected call of CNPeers.
 func (mr *MockPeerSetMockRecorder) CNPeers() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CNPeers", reflect.TypeOf((*MockPeerSet)(nil).CNPeers))
 }
 
-// CNWithoutTx mocks base method
+// CNWithoutTx mocks base method.
 func (m *MockPeerSet) CNWithoutTx(arg0 common.Hash) []Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CNWithoutTx", arg0)
@@ -73,25 +73,25 @@ func (m *MockPeerSet) CNWithoutTx(arg0 common.Hash) []Peer {
 	return ret0
 }
 
-// CNWithoutTx indicates an expected call of CNWithoutTx
+// CNWithoutTx indicates an expected call of CNWithoutTx.
 func (mr *MockPeerSetMockRecorder) CNWithoutTx(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CNWithoutTx", reflect.TypeOf((*MockPeerSet)(nil).CNWithoutTx), arg0)
 }
 
-// Close mocks base method
+// Close mocks base method.
 func (m *MockPeerSet) Close() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Close")
 }
 
-// Close indicates an expected call of Close
+// Close indicates an expected call of Close.
 func (mr *MockPeerSetMockRecorder) Close() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPeerSet)(nil).Close))
 }
 
-// ENPeers mocks base method
+// ENPeers mocks base method.
 func (m *MockPeerSet) ENPeers() map[common.Address]Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ENPeers")
@@ -99,13 +99,13 @@ func (m *MockPeerSet) ENPeers() map[common.Address]Peer {
 	return ret0
 }
 
-// ENPeers indicates an expected call of ENPeers
+// ENPeers indicates an expected call of ENPeers.
 func (mr *MockPeerSetMockRecorder) ENPeers() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ENPeers", reflect.TypeOf((*MockPeerSet)(nil).ENPeers))
 }
 
-// Len mocks base method
+// Len mocks base method.
 func (m *MockPeerSet) Len() int {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Len")
@@ -113,13 +113,13 @@ func (m *MockPeerSet) Len() int {
 	return ret0
 }
 
-// Len indicates an expected call of Len
+// Len indicates an expected call of Len.
 func (mr *MockPeerSetMockRecorder) Len() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockPeerSet)(nil).Len))
 }
 
-// PNPeers mocks base method
+// PNPeers mocks base method.
 func (m *MockPeerSet) PNPeers() map[common.Address]Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PNPeers")
@@ -127,13 +127,13 @@ func (m *MockPeerSet) PNPeers() map[common.Address]Peer {
 	return ret0
 }
 
-// PNPeers indicates an expected call of PNPeers
+// PNPeers indicates an expected call of PNPeers.
 func (mr *MockPeerSetMockRecorder) PNPeers() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PNPeers", reflect.TypeOf((*MockPeerSet)(nil).PNPeers))
 }
 
-// Peer mocks base method
+// Peer mocks base method.
 func (m *MockPeerSet) Peer(arg0 string) Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Peer", arg0)
@@ -141,13 +141,13 @@ func (m *MockPeerSet) Peer(arg0 string) Peer {
 	return ret0
 }
 
-// Peer indicates an expected call of Peer
+// Peer indicates an expected call of Peer.
 func (mr *MockPeerSetMockRecorder) Peer(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Peer", reflect.TypeOf((*MockPeerSet)(nil).Peer), arg0)
 }
 
-// Peers mocks base method
+// Peers mocks base method.
 func (m *MockPeerSet) Peers() map[string]Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Peers")
@@ -155,13 +155,13 @@ func (m *MockPeerSet) Peers() map[string]Peer {
 	return ret0
 }
 
-// Peers indicates an expected call of Peers
+// Peers indicates an expected call of Peers.
 func (mr *MockPeerSetMockRecorder) Peers() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Peers", reflect.TypeOf((*MockPeerSet)(nil).Peers))
 }
 
-// PeersWithoutBlock mocks base method
+// PeersWithoutBlock mocks base method.
 func (m *MockPeerSet) PeersWithoutBlock(arg0 common.Hash) []Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PeersWithoutBlock", arg0)
@@ -169,13 +169,13 @@ func (m *MockPeerSet) PeersWithoutBlock(arg0 common.Hash) []Peer {
 	return ret0
 }
 
-// PeersWithoutBlock indicates an expected call of PeersWithoutBlock
+// PeersWithoutBlock indicates an expected call of PeersWithoutBlock.
 func (mr *MockPeerSetMockRecorder) PeersWithoutBlock(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeersWithoutBlock", reflect.TypeOf((*MockPeerSet)(nil).PeersWithoutBlock), arg0)
 }
 
-// PeersWithoutTx mocks base method
+// PeersWithoutTx mocks base method.
 func (m *MockPeerSet) PeersWithoutTx(arg0 common.Hash) []Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PeersWithoutTx", arg0)
@@ -183,13 +183,13 @@ func (m *MockPeerSet) PeersWithoutTx(arg0 common.Hash) []Peer {
 	return ret0
 }
 
-// PeersWithoutTx indicates an expected call of PeersWithoutTx
+// PeersWithoutTx indicates an expected call of PeersWithoutTx.
 func (mr *MockPeerSetMockRecorder) PeersWithoutTx(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeersWithoutTx", reflect.TypeOf((*MockPeerSet)(nil).PeersWithoutTx), arg0)
 }
 
-// Register mocks base method
+// Register mocks base method.
 func (m *MockPeerSet) Register(arg0 Peer, arg1 *snap.Peer) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Register", arg0, arg1)
@@ -197,13 +197,13 @@ func (m *MockPeerSet) Register(arg0 Peer, arg1 *snap.Peer) error {
 	return ret0
 }
 
-// Register indicates an expected call of Register
+// Register indicates an expected call of Register.
 func (mr *MockPeerSetMockRecorder) Register(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Register", reflect.TypeOf((*MockPeerSet)(nil).Register), arg0, arg1)
 }
 
-// RegisterSnapExtension mocks base method
+// RegisterSnapExtension mocks base method.
 func (m *MockPeerSet) RegisterSnapExtension(arg0 *snap.Peer) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RegisterSnapExtension", arg0)
@@ -211,25 +211,25 @@ func (m *MockPeerSet) RegisterSnapExtension(arg0 *snap.Peer) error {
 	return ret0
 }
 
-// RegisterSnapExtension indicates an expected call of RegisterSnapExtension
+// RegisterSnapExtension indicates an expected call of RegisterSnapExtension.
 func (mr *MockPeerSetMockRecorder) RegisterSnapExtension(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterSnapExtension", reflect.TypeOf((*MockPeerSet)(nil).RegisterSnapExtension), arg0)
 }
 
-// RegisterValidator mocks base method
+// RegisterValidator mocks base method.
 func (m *MockPeerSet) RegisterValidator(arg0 common.ConnType, arg1 p2p.PeerTypeValidator) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "RegisterValidator", arg0, arg1)
 }
 
-// RegisterValidator indicates an expected call of RegisterValidator
+// RegisterValidator indicates an expected call of RegisterValidator.
 func (mr *MockPeerSetMockRecorder) RegisterValidator(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterValidator", reflect.TypeOf((*MockPeerSet)(nil).RegisterValidator), arg0, arg1)
 }
 
-// SamplePeersToSendBlock mocks base method
+// SamplePeersToSendBlock mocks base method.
 func (m *MockPeerSet) SamplePeersToSendBlock(arg0 *types.Block, arg1 common.ConnType) []Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SamplePeersToSendBlock", arg0, arg1)
@@ -237,13 +237,13 @@ func (m *MockPeerSet) SamplePeersToSendBlock(arg0 *types.Block, arg1 common.Conn
 	return ret0
 }
 
-// SamplePeersToSendBlock indicates an expected call of SamplePeersToSendBlock
+// SamplePeersToSendBlock indicates an expected call of SamplePeersToSendBlock.
 func (mr *MockPeerSetMockRecorder) SamplePeersToSendBlock(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SamplePeersToSendBlock", reflect.TypeOf((*MockPeerSet)(nil).SamplePeersToSendBlock), arg0, arg1)
 }
 
-// SampleResendPeersByType mocks base method
+// SampleResendPeersByType mocks base method.
 func (m *MockPeerSet) SampleResendPeersByType(arg0 common.ConnType) []Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SampleResendPeersByType", arg0)
@@ -251,13 +251,13 @@ func (m *MockPeerSet) SampleResendPeersByType(arg0 common.ConnType) []Peer {
 	return ret0
 }
 
-// SampleResendPeersByType indicates an expected call of SampleResendPeersByType
+// SampleResendPeersByType indicates an expected call of SampleResendPeersByType.
 func (mr *MockPeerSetMockRecorder) SampleResendPeersByType(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SampleResendPeersByType", reflect.TypeOf((*MockPeerSet)(nil).SampleResendPeersByType), arg0)
 }
 
-// SnapLen mocks base method
+// SnapLen mocks base method.
 func (m *MockPeerSet) SnapLen() int {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SnapLen")
@@ -265,13 +265,13 @@ func (m *MockPeerSet) SnapLen() int {
 	return ret0
 }
 
-// SnapLen indicates an expected call of SnapLen
+// SnapLen indicates an expected call of SnapLen.
 func (mr *MockPeerSetMockRecorder) SnapLen() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SnapLen", reflect.TypeOf((*MockPeerSet)(nil).SnapLen))
 }
 
-// TypePeersWithoutTx mocks base method
+// TypePeersWithoutTx mocks base method.
 func (m *MockPeerSet) TypePeersWithoutTx(arg0 common.Hash, arg1 common.ConnType) []Peer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "TypePeersWithoutTx", arg0, arg1)
@@ -279,13 +279,13 @@ func (m *MockPeerSet) TypePeersWithoutTx(arg0 common.Hash, arg1 common.ConnType)
 	return ret0
 }
 
-// TypePeersWithoutTx indicates an expected call of TypePeersWithoutTx
+// TypePeersWithoutTx indicates an expected call of TypePeersWithoutTx.
 func (mr *MockPeerSetMockRecorder) TypePeersWithoutTx(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypePeersWithoutTx", reflect.TypeOf((*MockPeerSet)(nil).TypePeersWithoutTx), arg0, arg1)
 }
 
-// Unregister mocks base method
+// Unregister mocks base method.
 func (m *MockPeerSet) Unregister(arg0 string) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Unregister", arg0)
@@ -293,25 +293,25 @@ func (m *MockPeerSet) Unregister(arg0 string) error {
 	return ret0
 }
 
-// Unregister indicates an expected call of Unregister
+// Unregister indicates an expected call of Unregister.
 func (mr *MockPeerSetMockRecorder) Unregister(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unregister", reflect.TypeOf((*MockPeerSet)(nil).Unregister), arg0)
 }
 
-// UpdateTypePeersWithoutTxs mocks base method
+// UpdateTypePeersWithoutTxs mocks base method.
 func (m *MockPeerSet) UpdateTypePeersWithoutTxs(arg0 *types.Transaction, arg1 common.ConnType, arg2 map[Peer]types.Transactions) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdateTypePeersWithoutTxs", arg0, arg1, arg2)
 }
 
-// UpdateTypePeersWithoutTxs indicates an expected call of UpdateTypePeersWithoutTxs
+// UpdateTypePeersWithoutTxs indicates an expected call of UpdateTypePeersWithoutTxs.
 func (mr *MockPeerSetMockRecorder) UpdateTypePeersWithoutTxs(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTypePeersWithoutTxs", reflect.TypeOf((*MockPeerSet)(nil).UpdateTypePeersWithoutTxs), arg0, arg1, arg2)
 }
 
-// WaitSnapExtension mocks base method
+// WaitSnapExtension mocks base method.
 func (m *MockPeerSet) WaitSnapExtension(arg0 Peer) (*snap.Peer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "WaitSnapExtension", arg0)
@@ -320,7 +320,7 @@ func (m *MockPeerSet) WaitSnapExtension(arg0 Peer) (*snap.Peer, error) {
 	return ret0, ret1
 }
 
-// WaitSnapExtension indicates an expected call of WaitSnapExtension
+// WaitSnapExtension indicates an expected call of WaitSnapExtension.
 func (mr *MockPeerSetMockRecorder) WaitSnapExtension(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitSnapExtension", reflect.TypeOf((*MockPeerSet)(nil).WaitSnapExtension), arg0)
diff --git a/node/sc/local_backend.go b/node/sc/local_backend.go
index a80d6cea3..41e49001a 100644
--- a/node/sc/local_backend.go
+++ b/node/sc/local_backend.go
@@ -28,6 +28,7 @@ import (
 
 	"github.com/kaiachain/kaia/blockchain"
 	"github.com/kaiachain/kaia/blockchain/bloombits"
+	"github.com/kaiachain/kaia/blockchain/state"
 	"github.com/kaiachain/kaia/blockchain/types"
 	"github.com/kaiachain/kaia/common"
 	"github.com/kaiachain/kaia/event"
@@ -84,6 +85,11 @@ func (fb *filterLocalBackend) GetBlockReceipts(ctx context.Context, hash common.
 	return fb.subbridge.blockchain.GetReceiptsByBlockHash(hash)
 }
 
+func (fb *filterLocalBackend) Pending() (*types.Block, types.Receipts, *state.StateDB) {
+	// Not supported
+	return nil, nil, nil
+}
+
 func (fb *filterLocalBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*types.Log, error) {
 	if err := checkCtx(ctx); err != nil {
 		return nil, err
diff --git a/node/sc/subbridge.go b/node/sc/subbridge.go
index 70019a6b3..05c0dd774 100644
--- a/node/sc/subbridge.go
+++ b/node/sc/subbridge.go
@@ -368,7 +368,7 @@ func (sb *SubBridge) SetComponents(components []interface{}) {
 		}
 	}
 
-	es := filters.NewEventSystem(sb.eventMux, &filterLocalBackend{sb}, false)
+	es := filters.NewEventSystem(sb.eventMux, &filterLocalBackend{sb})
 	sb.localBackend = backends.NewBlockchainContractBackend(sb.blockchain, sb.txPool, es)
 
 	sb.bridgeManager, err = NewBridgeManager(sb)
diff --git a/work/work.go b/work/work.go
index 724b55864..e424bc02a 100644
--- a/work/work.go
+++ b/work/work.go
@@ -210,8 +210,8 @@ func (self *Miner) SetExtra(extra []byte) error {
 	return nil
 }
 
-// Pending returns the currently pending block and associated state.
-func (self *Miner) Pending() (*types.Block, *state.StateDB) {
+// Pending returns the currently pending block, corresponding receipts and associated state.
+func (self *Miner) Pending() (*types.Block, types.Receipts, *state.StateDB) {
 	return self.worker.pending()
 }
 
diff --git a/work/worker.go b/work/worker.go
index 02f2b02ee..bcb28ad5c 100644
--- a/work/worker.go
+++ b/work/worker.go
@@ -160,9 +160,10 @@ type worker struct {
 	current    *Task
 	rewardbase common.Address
 
-	snapshotMu    sync.RWMutex
-	snapshotBlock *types.Block
-	snapshotState *state.StateDB
+	snapshotMu       sync.RWMutex // The lock used to protect the block snapshot and state snapshot
+	snapshotBlock    *types.Block
+	snapshotReceipts types.Receipts
+	snapshotState    *state.StateDB
 
 	// atomic status counters
 	mining int32
@@ -207,22 +208,22 @@ func (self *worker) setExtra(extra []byte) {
 	self.extra = extra
 }
 
-func (self *worker) pending() (*types.Block, *state.StateDB) {
+func (self *worker) pending() (*types.Block, types.Receipts, *state.StateDB) {
 	if atomic.LoadInt32(&self.mining) == 0 {
 		// return a snapshot to avoid contention on currentMu mutex
 		self.snapshotMu.RLock()
 		defer self.snapshotMu.RUnlock()
 		if self.snapshotState == nil {
-			return nil, nil
+			return nil, nil, nil
 		}
-		return self.snapshotBlock, self.snapshotState.Copy()
+		return self.snapshotBlock, self.snapshotReceipts, self.snapshotState.Copy()
 	}
 
 	self.currentMu.Lock()
 	defer self.currentMu.Unlock()
 	self.current.stateMu.Lock()
 	defer self.current.stateMu.Unlock()
-	return self.current.Block, self.current.state.Copy()
+	return self.current.Block, self.current.receipts, self.current.state.Copy()
 }
 
 func (self *worker) pendingBlock() *types.Block {
@@ -640,6 +641,7 @@ func (self *worker) updateSnapshot() {
 		self.current.txs,
 		self.current.receipts,
 	)
+	self.snapshotReceipts = self.current.receipts
 	self.snapshotState = self.current.state.Copy()
 }
 
diff --git a/work/worker_fake.go b/work/worker_fake.go
index 9244b2baa..2f80a1aec 100644
--- a/work/worker_fake.go
+++ b/work/worker_fake.go
@@ -39,6 +39,6 @@ func (*FakeWorker) Register(Agent)                                           {}
 func (*FakeWorker) Mining() bool                                             { return false }
 func (*FakeWorker) HashRate() (tot int64)                                    { return 0 }
 func (*FakeWorker) SetExtra([]byte) error                                    { return nil }
-func (*FakeWorker) Pending() (*types.Block, *state.StateDB)                  { return nil, nil }
+func (*FakeWorker) Pending() (*types.Block, types.Receipts, *state.StateDB)  { return nil, nil, nil }
 func (*FakeWorker) PendingBlock() *types.Block                               { return nil }
 func (*FakeWorker) RegisterExecutionModule(modules ...kaiax.ExecutionModule) {}