remove mmpa

go.mod

@@ -215,6 +215,7 @@ require (
 	github.com/libp2p/zeroconf/v2 v2.2.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
 	github.com/marten-seemann/tcp v0.0.0-20210406111302-dfbc87cc63fd // indirect
+	github.com/mattn/go-sqlite3 v1.14.6 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
 	github.com/miekg/dns v1.1.53 // indirect
 	github.com/mikioh/tcpinfo v0.0.0-20190314235526-30a79bb1804b // indirect
@@ -256,7 +257,6 @@ require (
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/samber/lo v1.36.0 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
-	github.com/stretchr/testify v1.8.4 // indirect
 	github.com/supranational/blst v0.3.11 // indirect
 	github.com/urfave/cli/v2 v2.25.7 // indirect
 	github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect
@@ -315,7 +315,7 @@ require (
 )
 
 require (
-	github.com/StackExchange/wmi v1.2.1 // indirect
+	github.com/VictoriaMetrics/fastcache v1.12.1 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 // indirect
@@ -327,7 +327,7 @@ require (
 	github.com/google/uuid v1.3.1 // indirect
 	github.com/gorilla/websocket v1.5.0 // indirect
 	github.com/hashicorp/go-bexpr v0.1.10 // indirect
-	github.com/hashicorp/golang-lru v1.0.2 // indirect
+	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
 	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect

staker/challenge-cache/cache.go

@@ -40,8 +40,6 @@ import (
 
 	protocol "github.com/OffchainLabs/bold/chain-abstraction"
 	l2stateprovider "github.com/OffchainLabs/bold/layer2-state-provider"
-	"github.com/OffchainLabs/bold/mmap"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 )
@@ -60,8 +58,8 @@ var (
 
 // HistoryCommitmentCacher can retrieve history commitment state roots given lookup keys.
 type HistoryCommitmentCacher interface {
-	Get(lookup *Key, numToRead uint64) (mmap.Mmap, error)
-	Put(lookup *Key, stateRoots mmap.Mmap) error
+	Get(lookup *Key, numToRead uint64) ([]common.Hash, error)
+	Put(lookup *Key, stateRoots []common.Hash) error
 }
 
 // Cache for history commitments on disk.
@@ -127,7 +125,7 @@ type Key struct {
 func (c *Cache) Get(
 	lookup *Key,
 	numToRead uint64,
-) (mmap.Mmap, error) {
+) ([]common.Hash, error) {
 	fName, err := determineFilePath(c.baseDir, lookup)
 	if err != nil {
 		return nil, err
@@ -153,7 +151,7 @@ func (c *Cache) Get(
 // State roots are saved as files in a directory hierarchy for the cache.
 // This function first creates a temporary file, writes the state roots to it, and then renames the file
 // to the final directory to ensure atomic writes.
-func (c *Cache) Put(lookup *Key, stateRoots mmap.Mmap) error {
+func (c *Cache) Put(lookup *Key, stateRoots []common.Hash) error {
 	// We should error if trying to put 0 state roots to disk.
 	if len(stateRoots) == 0 {
 		return ErrNoStateRoots
@@ -195,15 +193,11 @@ func (c *Cache) Put(lookup *Key, stateRoots mmap.Mmap) error {
 }
 
 // Reads 32 bytes at a time from a reader up to a specified height. If none, then read all.
-func readStateRoots(r io.Reader, numToRead uint64) (mmap.Mmap, error) {
+func readStateRoots(r io.Reader, numToRead uint64) ([]common.Hash, error) {
 	br := bufio.NewReader(r)
-	stateRootsMmap, err := mmap.NewMmap(int(numToRead))
-	if err != nil {
-		return nil, err
-	}
+	stateRoots := make([]common.Hash, 0)
 	buf := make([]byte, 0, 32)
-	var totalRead uint64
-	for totalRead = uint64(0); totalRead < numToRead; totalRead++ {
+	for totalRead := uint64(0); totalRead < numToRead; totalRead++ {
 		n, err := br.Read(buf[:cap(buf)])
 		if err != nil {
 			// If we try to read but reach EOF, we break out of the loop.
@@ -216,30 +210,30 @@ func readStateRoots(r io.Reader, numToRead uint64) (mmap.Mmap, error) {
 		if n != 32 {
 			return nil, fmt.Errorf("expected to read 32 bytes, got %d bytes", n)
 		}
-		stateRootsMmap.Set(int(totalRead), common.BytesToHash(buf))
+		stateRoots = append(stateRoots, common.BytesToHash(buf))
 	}
-	if protocol.Height(numToRead) > protocol.Height(totalRead) {
+	if protocol.Height(numToRead) > protocol.Height(len(stateRoots)) {
 		return nil, fmt.Errorf(
 			"wanted to read %d roots, but only read %d state roots",
 			numToRead,
-			totalRead,
+			len(stateRoots),
 		)
 	}
-	return stateRootsMmap, nil
+	return stateRoots, nil
 }
 
-func writeStateRoots(w io.Writer, stateRoots mmap.Mmap) error {
-	for i := 0; i < stateRoots.Length(); i++ {
-		n, err := w.Write(stateRoots.Get(i).Bytes())
+func writeStateRoots(w io.Writer, stateRoots []common.Hash) error {
+	for i, rt := range stateRoots {
+		n, err := w.Write(rt[:])
 		if err != nil {
 			return err
 		}
-		if n != len(stateRoots.Get(i)) {
+		if n != len(rt) {
 			return fmt.Errorf(
 				"for state root %d, wrote %d bytes, expected to write %d bytes",
 				i,
 				n,
-				len(stateRoots.Get(i)),
+				len(rt),
 			)
 		}
 	}

staker/challenge-cache/cache_test.go

@@ -12,8 +12,6 @@ import (
 	"testing"
 
 	l2stateprovider "github.com/OffchainLabs/bold/layer2-state-provider"
-	"github.com/OffchainLabs/bold/mmap"
-
 	"github.com/ethereum/go-ethereum/common"
 )
 
@@ -45,19 +43,16 @@ func TestCache(t *testing.T) {
 		}
 	})
 	t.Run("Putting empty root fails", func(t *testing.T) {
-		if err := cache.Put(key, mmap.Mmap{}); !errors.Is(err, ErrNoStateRoots) {
+		if err := cache.Put(key, []common.Hash{}); !errors.Is(err, ErrNoStateRoots) {
 			t.Fatalf("Unexpected error: %v", err)
 		}
 	})
-	want, err := mmap.NewMmap(3)
-	want.Set(0, common.BytesToHash([]byte("foo")))
-	want.Set(1, common.BytesToHash([]byte("bar")))
-	want.Set(2, common.BytesToHash([]byte("baz")))
-	if err != nil {
-		t.Fatal(err)
+	want := []common.Hash{
+		common.BytesToHash([]byte("foo")),
+		common.BytesToHash([]byte("bar")),
+		common.BytesToHash([]byte("baz")),
 	}
-	defer want.Free()
-	err = cache.Put(key, want)
+	err := cache.Put(key, want)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -97,7 +92,7 @@ func TestReadWriteStateRoots(t *testing.T) {
 		if len(roots) == 0 {
 			t.Fatal("Got no roots")
 		}
-		if roots.Get(0) != want {
+		if roots[0] != want {
 			t.Fatalf("Wrong root. Expected %#x, got %#x", want, roots[0])
 		}
 	})
@@ -113,30 +108,24 @@ func TestReadWriteStateRoots(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		if roots.Length() != 2 {
+		if len(roots) != 2 {
 			t.Fatalf("Expected two roots, got %d", len(roots))
 		}
-		if roots.Get(0) != foo {
+		if roots[0] != foo {
 			t.Fatalf("Wrong root. Expected %#x, got %#x", foo, roots[0])
 		}
-		if roots.Get(1) != bar {
+		if roots[1] != bar {
 			t.Fatalf("Wrong root. Expected %#x, got %#x", bar, roots[1])
 		}
 	})
 	t.Run("Fails to write enough data to writer", func(t *testing.T) {
 		m := &mockWriter{wantErr: true}
-		stateRoots, err := mmap.NewMmap(1)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer stateRoots.Free()
-		stateRoots.Set(0, common.BytesToHash([]byte("foo")))
-		err = writeStateRoots(m, stateRoots)
+		err := writeStateRoots(m, []common.Hash{common.BytesToHash([]byte("foo"))})
 		if err == nil {
 			t.Fatal("Wanted error")
 		}
 		m = &mockWriter{wantErr: false, numWritten: 16}
-		err = writeStateRoots(m, stateRoots)
+		err = writeStateRoots(m, []common.Hash{common.BytesToHash([]byte("foo"))})
 		if err == nil {
 			t.Fatal("Wanted error")
 		}
@@ -235,11 +224,11 @@ func Test_readStateRoots(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		if len(want) != got.Length() {
+		if len(want) != len(got) {
 			t.Fatal("Wrong number of roots")
 		}
-		for i := 0; i < got.Length(); i++ {
-			if got.Get(i) != want[i] {
+		for i, rt := range got {
+			if rt != want[i] {
 				t.Fatal("Wrong root")
 			}
 		}
@@ -314,15 +303,11 @@ func BenchmarkCache_Read_32Mb(b *testing.B) {
 		StepHeights:    []l2stateprovider.Height{l2stateprovider.Height(0)},
 	}
 	numRoots := 1 << 20
-	rootsMmap, err := mmap.NewMmap(numRoots)
-	if err != nil {
-		b.Fatal(err)
-	}
-	defer rootsMmap.Free()
-	for i := 0; i < numRoots; i++ {
-		rootsMmap.Set(i, common.BytesToHash([]byte(fmt.Sprintf("%d", i))))
+	roots := make([]common.Hash, numRoots)
+	for i := range roots {
+		roots[i] = common.BytesToHash([]byte(fmt.Sprintf("%d", i)))
 	}
-	if err := cache.Put(key, rootsMmap); err != nil {
+	if err := cache.Put(key, roots); err != nil {
 		b.Fatal(err)
 	}
 	b.StartTimer()