diff --git a/core/rawdb/accessors_indexes.go b/core/rawdb/accessors_indexes.go
index aed78f9a1fcf..d1b0cf5053a6 100644
--- a/core/rawdb/accessors_indexes.go
+++ b/core/rawdb/accessors_indexes.go
@@ -184,8 +184,8 @@ func DeleteBloombits(db ethdb.Database, bit uint, from uint64, to uint64) {
 
 var emptyRow = []uint32{}
 
-// ReadFilterMapRow retrieves a binary encoded filter map row at the given
-// mapRowIndex (see filtermaps.mapRowIndex for the storage index encoding).
+// ReadFilterMapRow retrieves a filter map row at the given mapRowIndex
+// (see filtermaps.mapRowIndex for the storage index encoding).
 // Note that zero length rows are not stored in the database and therefore all
 // non-existent entries are interpreted as empty rows and return no error.
 // Also note that the mapRowIndex indexing scheme is the same as the one
@@ -296,6 +296,8 @@ func DeleteBlockLvPointer(db ethdb.KeyValueWriter, blockNumber uint64) {
 	}
 }
 
+// FilterMapsRange is a storage representation of the block range covered by the
+// filter maps structure and the corresponting log value index range.
 type FilterMapsRange struct {
 	Initialized                      bool
 	HeadLvPointer, TailLvPointer     uint64
@@ -303,6 +305,9 @@ type FilterMapsRange struct {
 	HeadBlockHash, TailParentHash    common.Hash
 }
 
+// ReadFilterMapsRange retrieves the filter maps range data. Note that if the
+// database entry is not present, that is interpreted as a valid non-initialized
+// state and returns a blank range structure and no error.
 func ReadFilterMapsRange(db ethdb.KeyValueReader) (FilterMapsRange, error) {
 	if has, err := db.Has(filterMapsRangeKey); !has || err != nil {
 		return FilterMapsRange{}, err
@@ -318,6 +323,7 @@ func ReadFilterMapsRange(db ethdb.KeyValueReader) (FilterMapsRange, error) {
 	return fmRange, err
 }
 
+// WriteFilterMapsRange stores the filter maps range data.
 func WriteFilterMapsRange(db ethdb.KeyValueWriter, fmRange FilterMapsRange) {
 	encRange, err := rlp.EncodeToBytes(&fmRange)
 	if err != nil {
@@ -328,18 +334,24 @@ func WriteFilterMapsRange(db ethdb.KeyValueWriter, fmRange FilterMapsRange) {
 	}
 }
 
+// DeleteFilterMapsRange deletes the filter maps range data which is interpreted
+// as reverting to the un-initialized state.
 func DeleteFilterMapsRange(db ethdb.KeyValueWriter) {
 	if err := db.Delete(filterMapsRangeKey); err != nil {
 		log.Crit("Failed to delete filter maps range", "err", err)
 	}
 }
 
+// RevertPoint is the storage representation of a filter maps revert point.
 type RevertPoint struct {
 	BlockHash common.Hash
 	MapIndex  uint32
 	RowLength []uint
 }
 
+// ReadRevertPoint retrieves the revert point for the given block number if
+// present. Note that revert points may or may not exist for any block number
+// and a non-existent entry causes no error.
 func ReadRevertPoint(db ethdb.KeyValueReader, blockNumber uint64) (*RevertPoint, error) {
 	key := revertPointKey(blockNumber)
 	if has, err := db.Has(key); !has || err != nil {
@@ -356,6 +368,7 @@ func ReadRevertPoint(db ethdb.KeyValueReader, blockNumber uint64) (*RevertPoint,
 	return rp, nil
 }
 
+// WriteRevertPoint stores a revert point for the given block number.
 func WriteRevertPoint(db ethdb.KeyValueWriter, blockNumber uint64, rp *RevertPoint) {
 	enc, err := rlp.EncodeToBytes(rp)
 	if err != nil {
@@ -366,6 +379,7 @@ func WriteRevertPoint(db ethdb.KeyValueWriter, blockNumber uint64, rp *RevertPoi
 	}
 }
 
+// DeleteRevertPoint deletes the given revert point.
 func DeleteRevertPoint(db ethdb.KeyValueWriter, blockNumber uint64) {
 	if err := db.Delete(revertPointKey(blockNumber)); err != nil {
 		log.Crit("Failed to delete revert point", "err", err)