From d6cc6019215f33227e5e6c1e5cd3428c0333accf Mon Sep 17 00:00:00 2001
From: "lightclient@protonmail.com" <lightclient@protonmail.com>
Date: Tue, 23 May 2023 13:21:46 +0200
Subject: [PATCH] internal/era: better abstraction between era and e2store

---
 internal/era/e2store/e2store.go | 30 ++++++++++++++++++++----------
 internal/era/era.go             |  4 ++--
 2 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/internal/era/e2store/e2store.go b/internal/era/e2store/e2store.go
index 2e51b72978..e5337ce788 100644
--- a/internal/era/e2store/e2store.go
+++ b/internal/era/e2store/e2store.go
@@ -23,7 +23,7 @@ import (
 )
 
 const (
-	HeaderSize     = 8
+	headerSize     = 8
 	valueSizeLimit = 1024 * 1024 * 50
 )
 
@@ -50,7 +50,7 @@ func NewWriter(w io.Writer) *Writer {
 // record store the type (2 bytes), the length (4 bytes), and some reserved
 // data (2 bytes). The remaining bytes store b.
 func (w *Writer) Write(typ uint16, b []byte) (int, error) {
-	buf := make([]byte, HeaderSize+len(b))
+	buf := make([]byte, headerSize+len(b))
 	binary.LittleEndian.PutUint16(buf, typ)
 	binary.LittleEndian.PutUint32(buf[2:], uint32(len(b)))
 	copy(buf[8:], b)
@@ -91,16 +91,16 @@ func (r *Reader) ReadAt(entry *Entry, off int64) (int, error) {
 
 	// Check length bounds.
 	if length > valueSizeLimit {
-		return HeaderSize, fmt.Errorf("item larger than item size limit %d: have %d", valueSizeLimit, length)
+		return headerSize, fmt.Errorf("item larger than item size limit %d: have %d", valueSizeLimit, length)
 	}
 	if length == 0 {
-		return HeaderSize, nil
+		return headerSize, nil
 	}
 
 	// Read value.
 	val := make([]byte, length)
-	if n, err := r.r.ReadAt(val, off+HeaderSize); err != nil {
-		n += HeaderSize
+	if n, err := r.r.ReadAt(val, off+headerSize); err != nil {
+		n += headerSize
 		// An entry with a non-zero length should not return EOF when
 		// reading the value.
 		if err == io.EOF {
@@ -109,12 +109,22 @@ func (r *Reader) ReadAt(entry *Entry, off int64) (int, error) {
 		return n, err
 	}
 	entry.Value = val
-	return int(HeaderSize + length), nil
+	return int(headerSize + length), nil
+}
+
+// Reads the header at off and returns the total length of the entry, including
+// header.
+func (r *Reader) LengthAt(off int64) (int64, error) {
+	_, length, err := r.ReadMetadataAt(off)
+	if err != nil {
+		return 0, err
+	}
+	return int64(length) + headerSize, nil
 }
 
 // ReadMetadataAt reads the header metadata at the given offset.
 func (r *Reader) ReadMetadataAt(off int64) (typ uint16, length uint32, err error) {
-	b := make([]byte, HeaderSize)
+	b := make([]byte, headerSize)
 	if n, err := r.r.ReadAt(b, off); err != nil {
 		if err == io.EOF && n > 0 {
 			return 0, 0, io.ErrUnexpectedEOF
@@ -154,7 +164,7 @@ func (r *Reader) Find(want uint16) (*Entry, error) {
 			}
 			return &e, nil
 		}
-		off += int64(HeaderSize + length)
+		off += int64(headerSize + length)
 	}
 }
 
@@ -181,6 +191,6 @@ func (r *Reader) FindAll(want uint16) ([]*Entry, error) {
 			}
 			entries = append(entries, e)
 		}
-		off += int64(HeaderSize + length)
+		off += int64(headerSize + length)
 	}
 }
diff --git a/internal/era/era.go b/internal/era/era.go
index 195d526143..b516b8403f 100644
--- a/internal/era/era.go
+++ b/internal/era/era.go
@@ -171,11 +171,11 @@ func (r *Reader) ReadHeaderRLP(n uint64) ([]byte, error) {
 
 func skipN(r *Reader, off int64, n int) (int64, error) {
 	for i := 0; i < n; i++ {
-		_, length, err := r.e.ReadMetadataAt(off) // header
+		length, err := r.e.LengthAt(off)
 		if err != nil {
 			return off, err
 		}
-		off += e2store.HeaderSize + int64(length)
+		off += length
 	}
 	return off, nil
 }