chore(stateDB): renamed statedb.Copy (#2958)

Signed-off-by: Alberto Benegiamo <alberto.benegiamo@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: abi87

beacon/blockchain/process_proposal.go

@@ -262,9 +262,9 @@ func (s *Service) VerifyIncomingBlock(
 	)
 
 	if shouldBuildNextBlock {
-		// state copy makes sure that preFetchBuildData does not affect state
-		copiedState := state.Copy(ctx)
-		nextBlockData, errFetch = s.preFetchBuildData(copiedState, blk.GetConsensusTime())
+		// makes sure that preFetchBuildData does not affect state
+		ephemeralState := state.Protect(ctx)
+		nextBlockData, errFetch = s.preFetchBuildData(ephemeralState, blk.GetConsensusTime())
 		if errFetch != nil {
 			// We don't return with err if pre-fetch fails. Instead we log the issue
 			// and still move to process the current block. Next block can always be
@@ -303,9 +303,9 @@ func (s *Service) VerifyIncomingBlock(
 	)
 
 	if shouldBuildNextBlock {
-		// state copy makes sure that preFetchBuildDataForSuccess does not affect state
-		copiedState := state.Copy(ctx)
-		nextBlockData, errFetch = s.preFetchBuildData(copiedState, blk.GetConsensusTime())
+		// makes sure that preFetchBuildDataForSuccess does not affect state
+		ephemeralState := state.Protect(ctx)
+		nextBlockData, errFetch = s.preFetchBuildData(ephemeralState, blk.GetConsensusTime())
 		if errFetch != nil {
 			// We don't mark the block as rejected if it is valid but pre-fetch fails.
 			// Instead we log the issue and move to process the current block.

node-api/backend/getters.go

@@ -63,9 +63,9 @@ func (b *Backend) StateAndSlotFromHeight(height int64) (ReadOnlyBeaconState, mat
 		// Copy the state to ensure clients potential changes won't pollute the state
 		// Also we make sure to create the copy in a thread-safe way via the muCms mutex.
 		ms := b.cms.CacheMultiStore()
-		copyCtx := sdk.NewContext(ms, true, log.NewNopLogger())
-		copyGenesisState := b.genesisState.Copy(copyCtx)
-		return copyGenesisState, 0, nil
+		ctx := sdk.NewContext(ms, true, log.NewNopLogger())
+		ephemeralGenesisState := b.genesisState.Protect(ctx)
+		return ephemeralGenesisState, 0, nil
 	}
 
 	height = max(0, height) // CreateQueryContext uses 0 to pick latest height.

state-transition/core/state/statedb.go

@@ -57,8 +57,13 @@ func NewBeaconStateFromDB(
 	}
 }
 
-// Copy returns a copy of the beacon state.
-func (s *StateDB) Copy(ctx context.Context) *StateDB {
+// Protect returns an almost copy of stateDB. Specifically Protect guarantees that:
+// - No changes done on the returned state will affect the original state
+// - However, changes done on the original state will be carried over to the returned state.
+// The behaviour is probably best understood by considering the context hosts a stack of cache layers.
+// So write operations to the top cache won't be flushed to the lower layer but read operations will walk
+// through the cache stack, so bubbling up changes from the lower layers to the top ones.
+func (s *StateDB) Protect(ctx context.Context) *StateDB {
 	return NewBeaconStateFromDB(s.KVStore.Copy(ctx), s.cs, s.logger, s.telemetrySink)
 }
 

state-transition/core/state/statedb_test.go

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: BUSL-1.1
+//
+// Copyright (C) 2025, Berachain Foundation. All rights reserved.
+// Use of this software is governed by the Business Source License included
+// in the LICENSE file of this repository and at www.mariadb.com/bsl11.
+//
+// ANY USE OF THE LICENSED WORK IN VIOLATION OF THIS LICENSE WILL AUTOMATICALLY
+// TERMINATE YOUR RIGHTS UNDER THIS LICENSE FOR THE CURRENT AND ALL OTHER
+// VERSIONS OF THE LICENSED WORK.
+//
+// THIS LICENSE DOES NOT GRANT YOU ANY RIGHT IN ANY TRADEMARK OR LOGO OF
+// LICENSOR OR ITS AFFILIATES (PROVIDED THAT YOU MAY USE A TRADEMARK OR LOGO OF
+// LICENSOR AS EXPRESSLY REQUIRED BY THIS LICENSE).
+//
+// TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+// AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+// EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+// TITLE.
+
+package state_test
+
+import (
+	"testing"
+
+	"cosmossdk.io/collections"
+	"cosmossdk.io/log"
+	"cosmossdk.io/store"
+	sdkmetrics "cosmossdk.io/store/metrics"
+	storetypes "cosmossdk.io/store/types"
+	"github.com/berachain/beacon-kit/config/spec"
+	ctypes "github.com/berachain/beacon-kit/consensus-types/types"
+	"github.com/berachain/beacon-kit/node-core/components/metrics"
+	"github.com/berachain/beacon-kit/primitives/common"
+	"github.com/berachain/beacon-kit/primitives/math"
+	"github.com/berachain/beacon-kit/state-transition/core/state"
+	"github.com/berachain/beacon-kit/storage"
+	"github.com/berachain/beacon-kit/storage/beacondb"
+	"github.com/berachain/beacon-kit/storage/db"
+	dbm "github.com/cosmos/cosmos-db"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestStateProtect(t *testing.T) {
+	t.Parallel()
+
+	db, err := db.OpenDB("", dbm.MemDBBackend)
+	require.NoError(t, err)
+
+	cs, errSpec := spec.MainnetChainSpec()
+	require.NoError(t, errSpec)
+
+	var (
+		nopLog     = log.NewNopLogger()
+		nopMetrics = sdkmetrics.NewNoOpMetrics()
+	)
+
+	cms := store.NewCommitMultiStore(db, nopLog, nopMetrics)
+	cms.MountStoreWithDB(testStoreKey, storetypes.StoreTypeIAVL, nil)
+	require.NoError(t, cms.LoadLatestVersion())
+
+	backendStoreService := &storage.KVStoreService{Key: testStoreKey}
+	kvStore := beacondb.New(backendStoreService)
+
+	ms := cms.CacheMultiStore()
+	sdkCtx := sdk.NewContext(ms, true, nopLog)
+	originalState := state.NewBeaconStateFromDB(
+		kvStore.WithContext(sdkCtx),
+		cs,
+		sdkCtx.Logger(),
+		metrics.NewNoOpTelemetrySink(),
+	)
+
+	protectingState := originalState.Protect(sdkCtx)
+
+	// 1- set an attribute in the original state and show
+	// that value is carried over the protecting state
+	wantSlot := math.Slot(1234)
+	require.NoError(t, originalState.SetSlot(wantSlot))
+
+	gotSlot, err := protectingState.GetSlot()
+	require.NoError(t, err)
+	require.Equal(t, wantSlot, gotSlot)
+
+	// 2- Show that modifying the protecting state
+	// does not affect the original state
+	wantFork := &ctypes.Fork{
+		PreviousVersion: common.Version{0x11, 0x22, 0x33, 0x44},
+		CurrentVersion:  common.Version{0xff, 0xff, 0xff, 0xff},
+		Epoch:           math.Epoch(1234),
+	}
+	require.NoError(t, protectingState.SetFork(wantFork))
+
+	_, err = originalState.GetFork()
+	require.ErrorIs(t, err, collections.ErrNotFound)
+
+	// 3- Show that changes made to original state after protection
+	// are carried over the protecting state
+	wantEthIdx := uint64(1987)
+	require.NoError(t, originalState.SetEth1DepositIndex(wantEthIdx))
+
+	gotEthIdx, err := protectingState.GetEth1DepositIndex()
+	require.NoError(t, err)
+	require.Equal(t, wantEthIdx, gotEthIdx)
+}
+
+var testStoreKey = storetypes.NewKVStoreKey("test-stateDB")

testing/simulated/utils.go

@@ -326,8 +326,9 @@ func ComputeAndSetStateRoot(
 	block *ctypes.BeaconBlock,
 ) (*ctypes.BeaconBlock, error) {
 
-	// Copy the current state from the storage backend.
-	stateDBCopy := storageBackend.StateFromContext(queryCtx).Copy(queryCtx)
+	// Create an ephemeral state out of storage backend to avoid polluting
+	// the original state
+	ephemeralState := storageBackend.StateFromContext(queryCtx).Protect(queryCtx)
 
 	// Create a transition context with the provided consensus time and proposer address.
 	txCtx := transition.NewTransitionCtx(
@@ -340,13 +341,13 @@ func ComputeAndSetStateRoot(
 		WithMeterGas(false)
 
 	// Run the state transition.
-	_, err := stateProcessor.Transition(txCtx, stateDBCopy, block)
+	_, err := stateProcessor.Transition(txCtx, ephemeralState, block)
 	if err != nil {
 		return nil, fmt.Errorf("state transition failed: %w", err)
 	}
 
 	// Compute the new state root from the updated state.
-	newStateRoot := stateDBCopy.HashTreeRoot()
+	newStateRoot := ephemeralState.HashTreeRoot()
 	block.SetStateRoot(newStateRoot)
 	return block, nil
 }