BOLD: Avoid repeating the last hash in state hashes

staker/challenge-cache/cache.go

@@ -38,6 +38,8 @@ import (
 	"path/filepath"
 	"strings"
 
+	state_hashes "github.com/OffchainLabs/bold/state-commitments/state-hashes"
+
 	protocol "github.com/OffchainLabs/bold/chain-abstraction"
 	l2stateprovider "github.com/OffchainLabs/bold/layer2-state-provider"
 	"github.com/ethereum/go-ethereum/common"
@@ -58,8 +60,8 @@ var (
 
 // HistoryCommitmentCacher can retrieve history commitment state roots given lookup keys.
 type HistoryCommitmentCacher interface {
-	Get(lookup *Key, numToRead uint64) ([]common.Hash, error)
-	Put(lookup *Key, stateRoots []common.Hash) error
+	Get(lookup *Key, numToRead uint64) (*state_hashes.StateHashes, error)
+	Put(lookup *Key, stateRoots *state_hashes.StateHashes) error
 }
 
 // Cache for history commitments on disk.
@@ -88,7 +90,7 @@ type Key struct {
 func (c *Cache) Get(
 	lookup *Key,
 	numToRead uint64,
-) ([]common.Hash, error) {
+) (*state_hashes.StateHashes, error) {
 	fName, err := determineFilePath(c.baseDir, lookup)
 	if err != nil {
 		return nil, err
@@ -114,9 +116,9 @@ 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 []common.Hash) error {
+func (c *Cache) Put(lookup *Key, stateRoots *state_hashes.StateHashes) error {
 	// We should error if trying to put 0 state roots to disk.
-	if len(stateRoots) == 0 {
+	if stateRoots.Length() == 0 {
 		return ErrNoStateRoots
 	}
 	fName, err := determineFilePath(c.baseDir, lookup)
@@ -156,7 +158,7 @@ func (c *Cache) Put(lookup *Key, stateRoots []common.Hash) 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) ([]common.Hash, error) {
+func readStateRoots(r io.Reader, numToRead uint64) (*state_hashes.StateHashes, error) {
 	br := bufio.NewReader(r)
 	stateRoots := make([]common.Hash, 0)
 	buf := make([]byte, 0, 32)
@@ -182,21 +184,21 @@ func readStateRoots(r io.Reader, numToRead uint64) ([]common.Hash, error) {
 			len(stateRoots),
 		)
 	}
-	return stateRoots, nil
+	return state_hashes.NewStateHashes(stateRoots, uint64(len(stateRoots))), nil
 }
 
-func writeStateRoots(w io.Writer, stateRoots []common.Hash) error {
-	for i, rt := range stateRoots {
-		n, err := w.Write(rt[:])
+func writeStateRoots(w io.Writer, stateRoots *state_hashes.StateHashes) error {
+	for i := uint64(0); i < stateRoots.Length(); i++ {
+		n, err := w.Write(stateRoots.At(i).Bytes())
 		if err != nil {
 			return err
 		}
-		if n != len(rt) {
+		if n != len(stateRoots.At(i)) {
 			return fmt.Errorf(
 				"for state root %d, wrote %d bytes, expected to write %d bytes",
 				i,
 				n,
-				len(rt),
+				len(stateRoots.At(i)),
 			)
 		}
 	}

staker/challenge-cache/cache_test.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 
 	l2stateprovider "github.com/OffchainLabs/bold/layer2-state-provider"
+	state_hashes "github.com/OffchainLabs/bold/state-commitments/state-hashes"
 	"github.com/ethereum/go-ethereum/common"
 )
 
@@ -40,15 +41,16 @@ func TestCache(t *testing.T) {
 		}
 	})
 	t.Run("Putting empty root fails", func(t *testing.T) {
-		if err := cache.Put(key, []common.Hash{}); !errors.Is(err, ErrNoStateRoots) {
+		if err := cache.Put(key, state_hashes.NewStateHashes([]common.Hash{}, 0)); !errors.Is(err, ErrNoStateRoots) {
 			t.Fatalf("Unexpected error: %v", err)
 		}
 	})
-	want := []common.Hash{
+	wantHashes := []common.Hash{
 		common.BytesToHash([]byte("foo")),
 		common.BytesToHash([]byte("bar")),
 		common.BytesToHash([]byte("baz")),
 	}
+	want := state_hashes.NewStateHashes(wantHashes, uint64(len(wantHashes)))
 	err := cache.Put(key, want)
 	if err != nil {
 		t.Fatal(err)
@@ -57,12 +59,12 @@ func TestCache(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(got) != len(want) {
-		t.Fatalf("Wrong number of roots. Expected %d, got %d", len(want), len(got))
+	if got.Length() != want.Length() {
+		t.Fatalf("Wrong number of roots. Expected %d, got %d", want.Length(), got.Length())
 	}
-	for i, rt := range got {
-		if rt != want[i] {
-			t.Fatalf("Wrong root. Expected %#x, got %#x", want[i], rt)
+	for i := uint64(0); i < got.Length(); i++ {
+		if got.At(i) != want.At(i) {
+			t.Fatalf("Wrong root. Expected %#x, got %#x", want.At(i), got.At(i))
 		}
 	}
 }
@@ -86,11 +88,11 @@ func TestReadWriteStateRoots(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		if len(roots) == 0 {
+		if roots.Length() == 0 {
 			t.Fatal("Got no roots")
 		}
-		if roots[0] != want {
-			t.Fatalf("Wrong root. Expected %#x, got %#x", want, roots[0])
+		if roots.At(0) != want {
+			t.Fatalf("Wrong root. Expected %#x, got %#x", want, roots.At(0))
 		}
 	})
 	t.Run("Three roots exist, want to read only two", func(t *testing.T) {
@@ -105,24 +107,24 @@ func TestReadWriteStateRoots(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		if len(roots) != 2 {
-			t.Fatalf("Expected two roots, got %d", len(roots))
+		if roots.Length() != 2 {
+			t.Fatalf("Expected two roots, got %d", roots.Length())
 		}
-		if roots[0] != foo {
-			t.Fatalf("Wrong root. Expected %#x, got %#x", foo, roots[0])
+		if roots.At(0) != foo {
+			t.Fatalf("Wrong root. Expected %#x, got %#x", foo, roots.At(0))
 		}
-		if roots[1] != bar {
-			t.Fatalf("Wrong root. Expected %#x, got %#x", bar, roots[1])
+		if roots.At(1) != bar {
+			t.Fatalf("Wrong root. Expected %#x, got %#x", bar, roots.At(1))
 		}
 	})
 	t.Run("Fails to write enough data to writer", func(t *testing.T) {
 		m := &mockWriter{wantErr: true}
-		err := writeStateRoots(m, []common.Hash{common.BytesToHash([]byte("foo"))})
+		err := writeStateRoots(m, state_hashes.NewStateHashes([]common.Hash{common.BytesToHash([]byte("foo"))}, 1))
 		if err == nil {
 			t.Fatal("Wanted error")
 		}
 		m = &mockWriter{wantErr: false, numWritten: 16}
-		err = writeStateRoots(m, []common.Hash{common.BytesToHash([]byte("foo"))})
+		err = writeStateRoots(m, state_hashes.NewStateHashes([]common.Hash{common.BytesToHash([]byte("foo"))}, 1))
 		if err == nil {
 			t.Fatal("Wanted error")
 		}
@@ -221,11 +223,11 @@ func Test_readStateRoots(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		if len(want) != len(got) {
+		if uint64(len(want)) != got.Length() {
 			t.Fatal("Wrong number of roots")
 		}
-		for i, rt := range got {
-			if rt != want[i] {
+		for i := uint64(0); i < got.Length(); i++ {
+			if got.At(i) != want[i] {
 				t.Fatal("Wrong root")
 			}
 		}
@@ -297,10 +299,11 @@ func BenchmarkCache_Read_32Mb(b *testing.B) {
 		StepHeights:    []l2stateprovider.Height{l2stateprovider.Height(0)},
 	}
 	numRoots := 1 << 20
-	roots := make([]common.Hash, numRoots)
-	for i := range roots {
-		roots[i] = common.BytesToHash([]byte(fmt.Sprintf("%d", i)))
+	rootsHashes := make([]common.Hash, numRoots)
+	for i := range rootsHashes {
+		rootsHashes[i] = common.BytesToHash([]byte(fmt.Sprintf("%d", i)))
 	}
+	roots := state_hashes.NewStateHashes(rootsHashes, uint64(len(rootsHashes)))
 	if err := cache.Put(key, roots); err != nil {
 		b.Fatal(err)
 	}
@@ -311,8 +314,8 @@ func BenchmarkCache_Read_32Mb(b *testing.B) {
 		if err != nil {
 			b.Fatal(err)
 		}
-		if len(roots) != numRoots {
-			b.Fatalf("Wrong number of roots. Expected %d, got %d", numRoots, len(roots))
+		if roots.Length() != uint64(numRoots) {
+			b.Fatalf("Wrong number of roots. Expected %d, got %d", numRoots, roots.Length())
 		}
 	}
 }

staker/state_provider.go

@@ -17,6 +17,7 @@ import (
 	protocol "github.com/OffchainLabs/bold/chain-abstraction"
 	"github.com/OffchainLabs/bold/containers/option"
 	l2stateprovider "github.com/OffchainLabs/bold/layer2-state-provider"
+	state_hashes "github.com/OffchainLabs/bold/state-commitments/state-hashes"
 
 	"github.com/offchainlabs/nitro/arbutil"
 	challengecache "github.com/offchainlabs/nitro/staker/challenge-cache"
@@ -181,7 +182,7 @@ func (s *StateManager) StatesInBatchRange(
 	toHeight l2stateprovider.Height,
 	fromBatch,
 	toBatch l2stateprovider.Batch,
-) ([]common.Hash, error) {
+) (*state_hashes.StateHashes, error) {
 	// Check the integrity of the arguments.
 	if fromBatch >= toBatch {
 		return nil, fmt.Errorf("from batch %v cannot be greater than or equal to batch %v", fromBatch, toBatch)
@@ -256,10 +257,9 @@ func (s *StateManager) StatesInBatchRange(
 		machineHashes = append(machineHashes, machineHash(state))
 		prevBatchMsgCount = batchMessageCount
 	}
-	for uint64(len(machineHashes)) < uint64(totalDesiredHashes) {
-		machineHashes = append(machineHashes, machineHashes[len(machineHashes)-1])
-	}
-	return machineHashes[fromHeight : toHeight+1], nil
+	return state_hashes.NewStateHashes(
+		machineHashes, uint64(totalDesiredHashes),
+	).SubSlice(uint64(fromHeight), uint64(toHeight+1)), nil
 }
 
 func machineHash(gs validator.GoGlobalState) common.Hash {
@@ -299,7 +299,7 @@ func (s *StateManager) L2MessageStatesUpTo(
 	toHeight option.Option[l2stateprovider.Height],
 	fromBatch,
 	toBatch l2stateprovider.Batch,
-) ([]common.Hash, error) {
+) (*state_hashes.StateHashes, error) {
 	var to l2stateprovider.Height
 	if !toHeight.IsNone() {
 		to = toHeight.Unwrap()
@@ -317,7 +317,7 @@ func (s *StateManager) L2MessageStatesUpTo(
 // CollectMachineHashes Collects a list of machine hashes at a message number based on some configuration parameters.
 func (s *StateManager) CollectMachineHashes(
 	ctx context.Context, cfg *l2stateprovider.HashCollectorConfig,
-) ([]common.Hash, error) {
+) (*state_hashes.StateHashes, error) {
 	s.Lock()
 	defer s.Unlock()
 	prevBatchMsgCount, err := s.validator.inboxTracker.GetBatchMessageCount(uint64(cfg.FromBatch - 1))
@@ -360,7 +360,7 @@ func (s *StateManager) CollectMachineHashes(
 	}
 	log.Info(fmt.Sprintf("Finished gathering machine hashes for request %+v", cfg))
 	// Do not save a history commitment of length 1 to the cache.
-	if len(result) > 1 && s.historyCache != nil {
+	if result.Length() > 1 && s.historyCache != nil {
 		if err := s.historyCache.Put(cacheKey, result); err != nil {
 			if !errors.Is(err, challengecache.ErrFileAlreadyExists) {
 				return nil, err

system_tests/validation_mock_test.go

@@ -7,6 +7,8 @@
 	"testing"
 	"time"
 
+	state_hashes "github.com/OffchainLabs/bold/state-commitments/state-hashes"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/node"
@@ -72,7 +74,7 @@
 
 func (s *mockSpawner) CreateExecutionRun(wasmModuleRoot common.Hash, input *validator.ValidationInput) containers.PromiseInterface[validator.ExecutionRun] {
 	s.ExecSpawned = append(s.ExecSpawned, input.Id)
 	return containers.NewReadyPromise[validator.ExecutionRun](&mockExecRun{
 		startState: input.StartState,
 		endState:   globalstateFromTestPreimages(input.Preimages),
 	}, nil)
@@ -121,9 +123,9 @@
 	}, nil)
 }
 
-func (r *mockExecRun) GetLeavesWithStepSize(machineStartIndex, stepSize, numDesiredLeaves uint64, claimId common.Hash) containers.PromiseInterface[[]common.Hash] {
+func (r *mockExecRun) GetLeavesWithStepSize(machineStartIndex, stepSize, numDesiredLeaves uint64, claimId common.Hash) containers.PromiseInterface[*state_hashes.StateHashes] {
 	// TODO: Add mock implementation for GetLeavesWithStepSize
-	return containers.NewReadyPromise[[]common.Hash](nil, nil)
+	return containers.NewReadyPromise[*state_hashes.StateHashes](nil, nil)
 }
 
 func (r *mockExecRun) GetLastStep() containers.PromiseInterface[*validator.MachineStepResult] {

validator/interface.go

@@ -5,6 +5,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 
+	state_hashes "github.com/OffchainLabs/bold/state-commitments/state-hashes"
+
 	"github.com/offchainlabs/nitro/util/containers"
 )
 
@@ -31,7 +33,7 @@ type ExecutionSpawner interface {
 
 type ExecutionRun interface {
 	GetStepAt(uint64) containers.PromiseInterface[*MachineStepResult]
-	GetLeavesWithStepSize(fromBatch, machineStartIndex, stepSize, numDesiredLeaves uint64) containers.PromiseInterface[[]common.Hash]
+	GetLeavesWithStepSize(fromBatch, machineStartIndex, stepSize, numDesiredLeaves uint64) containers.PromiseInterface[*state_hashes.StateHashes]
 	GetLastStep() containers.PromiseInterface[*MachineStepResult]
 	GetProofAt(uint64) containers.PromiseInterface[[]byte]
 	PrepareRange(uint64, uint64) containers.PromiseInterface[struct{}]

validator/server_api/validation_api.go

@@ -8,6 +8,8 @@ import (
 	"sync"
 	"time"
 
+	state_hashes "github.com/OffchainLabs/bold/state-commitments/state-hashes"
+
 	"github.com/ethereum/go-ethereum/common"
 
 	"github.com/offchainlabs/nitro/util/stopwaiter"
@@ -159,7 +161,7 @@ func (a *ExecServerAPI) GetStepAt(ctx context.Context, execid uint64, position u
 	return MachineStepResultToJson(res), nil
 }
 
-func (a *ExecServerAPI) GetLeavesWithStepSize(ctx context.Context, execid, fromBatch, fromStep, stepSize, numDesiredLeaves uint64) ([]common.Hash, error) {
+func (a *ExecServerAPI) GetLeavesWithStepSize(ctx context.Context, execid, fromBatch, fromStep, stepSize, numDesiredLeaves uint64) (*state_hashes.StateHashes, error) {
 	run, err := a.getRun(execid)
 	if err != nil {
 		return nil, err

validator/server_api/validation_client.go

@@ -16,6 +16,8 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
+
+	state_hashes "github.com/OffchainLabs/bold/state-commitments/state-hashes"
 )
 
 type ValidationClient struct {
@@ -195,9 +197,9 @@ func (r *ExecutionClientRun) GetStepAt(pos uint64) containers.PromiseInterface[*
 	})
 }
 
-func (r *ExecutionClientRun) GetLeavesWithStepSize(fromBatch, machineStartIndex, stepSize, numDesiredLeaves uint64) containers.PromiseInterface[[]common.Hash] {
-	return stopwaiter.LaunchPromiseThread[[]common.Hash](r, func(ctx context.Context) ([]common.Hash, error) {
-		var resJson []common.Hash
+func (r *ExecutionClientRun) GetLeavesWithStepSize(fromBatch, machineStartIndex, stepSize, numDesiredLeaves uint64) containers.PromiseInterface[*state_hashes.StateHashes] {
+	return stopwaiter.LaunchPromiseThread[*state_hashes.StateHashes](r, func(ctx context.Context) (*state_hashes.StateHashes, error) {
+		var resJson *state_hashes.StateHashes
 		err := r.client.client.CallContext(ctx, &resJson, Namespace+"_getLeavesWithStepSize", r.id, fromBatch, machineStartIndex, stepSize, numDesiredLeaves)
 		if err != nil {
 			return nil, err

validator/server_arb/execution_run.go

@@ -11,8 +11,10 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-
 	"github.com/ethereum/go-ethereum/log"
+
+	state_hashes "github.com/OffchainLabs/bold/state-commitments/state-hashes"
+
 	"github.com/offchainlabs/nitro/util/containers"
 	"github.com/offchainlabs/nitro/util/stopwaiter"
 	"github.com/offchainlabs/nitro/validator"
@@ -64,8 +66,8 @@ func (e *executionRun) GetStepAt(position uint64) containers.PromiseInterface[*v
 	})
 }
 
-func (e *executionRun) GetLeavesWithStepSize(fromBatch, machineStartIndex, stepSize, numDesiredLeaves uint64) containers.PromiseInterface[[]common.Hash] {
-	return stopwaiter.LaunchPromiseThread[[]common.Hash](e, func(ctx context.Context) ([]common.Hash, error) {
+func (e *executionRun) GetLeavesWithStepSize(fromBatch, machineStartIndex, stepSize, numDesiredLeaves uint64) containers.PromiseInterface[*state_hashes.StateHashes] {
+	return stopwaiter.LaunchPromiseThread[*state_hashes.StateHashes](e, func(ctx context.Context) (*state_hashes.StateHashes, error) {
 		if stepSize == 1 {
 			e.cache = NewMachineCache(e.GetContext(), e.initialMachineGetter, e.config, server_common.WithAlwaysMerkleize())
 			log.Info("Enabling Merkleization of machines for faster hashing. However, advancing to start index might take a while...")
@@ -95,7 +97,7 @@ func (e *executionRun) GetLeavesWithStepSize(fromBatch, machineStartIndex, stepS
 
 		// If we only want 1 state root, we can return early.
 		if numDesiredLeaves == 1 {
-			return stateRoots, nil
+			return state_hashes.NewStateHashes(stateRoots, uint64(len(stateRoots))), nil
 		}
 
 		logInterval := numDesiredLeaves / 20 // Log every 5% progress
@@ -168,11 +170,7 @@ func (e *executionRun) GetLeavesWithStepSize(fromBatch, machineStartIndex, stepS
 		// If the machine finished in less than the number of hashes we anticipate, we pad
 		// to the expected value by repeating the last machine hash until the state roots are the correct
 		// length.
-		lastStateRoot := stateRoots[len(stateRoots)-1]
-		for len(stateRoots) < int(numDesiredLeaves) {
-			stateRoots = append(stateRoots, lastStateRoot)
-		}
-		return stateRoots[:numDesiredLeaves], nil
+		return state_hashes.NewStateHashes(stateRoots, numDesiredLeaves), nil
 	})
 }