handle predicates outside of core/state.StateDB

core/evm.go

@@ -31,6 +31,7 @@ import (
 
 	"github.com/ava-labs/coreth/consensus"
 	"github.com/ava-labs/coreth/consensus/misc/eip4844"
+	"github.com/ava-labs/coreth/core/extstate"
 	"github.com/ava-labs/coreth/core/state"
 	"github.com/ava-labs/coreth/core/types"
 	"github.com/ava-labs/coreth/core/vm"
@@ -44,9 +45,9 @@ import (
 func init() {
 	vm.StateDbHook = func(rules params.Rules, db vm.StateDB) vm.StateDB {
 		if rules.IsApricotPhase1 {
-			return &StateDbAP1{db}
+			db = &StateDbAP1{db}
 		}
-		return db
+		return &extstate.StateDB{StateDB: db}
 	}
 }
 

core/extstate/statedb.go

@@ -0,0 +1,54 @@
+// (c) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package extstate
+
+import (
+	"github.com/ava-labs/coreth/core/types"
+	"github.com/ava-labs/coreth/core/vm"
+	"github.com/ava-labs/coreth/params"
+	"github.com/ava-labs/coreth/predicate"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type StateDB struct {
+	vm.StateDB
+
+	// Ordered storage slots to be used in predicate verification as set in the tx access list.
+	// Only set in PrepareAccessList, and un-modified through execution.
+	predicateStorageSlots map[common.Address][][]byte
+}
+
+func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, dst *common.Address, precompiles []common.Address, list types.AccessList) {
+	s.predicateStorageSlots = predicate.PreparePredicateStorageSlots(rules, list)
+	s.StateDB.Prepare(rules, sender, coinbase, dst, precompiles, list)
+}
+
+// GetPredicateStorageSlots returns the storage slots associated with the address, index pair.
+// A list of access tuples can be included within transaction types post EIP-2930. The address
+// is declared directly on the access tuple and the index is the i'th occurrence of an access
+// tuple with the specified address.
+//
+// Ex. AccessList[[AddrA, Predicate1], [AddrB, Predicate2], [AddrA, Predicate3]]
+// In this case, the caller could retrieve predicates 1-3 with the following calls:
+// GetPredicateStorageSlots(AddrA, 0) -> Predicate1
+// GetPredicateStorageSlots(AddrB, 0) -> Predicate2
+// GetPredicateStorageSlots(AddrA, 1) -> Predicate3
+func (s *StateDB) GetPredicateStorageSlots(address common.Address, index int) ([]byte, bool) {
+	predicates, exists := s.predicateStorageSlots[address]
+	if !exists {
+		return nil, false
+	}
+	if index >= len(predicates) {
+		return nil, false
+	}
+	return predicates[index], true
+}
+
+// SetPredicateStorageSlots sets the predicate storage slots for the given address
+func (s *StateDB) SetPredicateStorageSlots(address common.Address, predicates [][]byte) {
+	if s.predicateStorageSlots == nil {
+		s.predicateStorageSlots = make(map[common.Address][][]byte)
+	}
+	s.predicateStorageSlots[address] = predicates
+}

core/state/test_statedb.go → core/extstate/test_statedb.go

@@ -1,19 +1,20 @@
 // (c) 2023, Ava Labs, Inc. All rights reserved.
 // See the file LICENSE for licensing terms.
-package state
+package extstate
 
 import (
 	"testing"
 
 	"github.com/ava-labs/coreth/core/rawdb"
+	"github.com/ava-labs/coreth/core/state"
 	"github.com/ava-labs/coreth/precompile/contract"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/require"
 )
 
 func NewTestStateDB(t testing.TB) contract.StateDB {
 	db := rawdb.NewMemoryDatabase()
-	stateDB, err := New(common.Hash{}, NewDatabase(db), nil)
+	stateDB, err := state.New(common.Hash{}, state.NewDatabase(db), nil)
 	require.NoError(t, err)
-	return stateDB
+	return &StateDB{StateDB: stateDB}
 }

core/state/statedb.go

@@ -38,7 +38,6 @@ import (
 	"github.com/ava-labs/coreth/core/types"
 	"github.com/ava-labs/coreth/metrics"
 	"github.com/ava-labs/coreth/params"
-	"github.com/ava-labs/coreth/predicate"
 	"github.com/ava-labs/coreth/trie"
 	"github.com/ava-labs/coreth/trie/trienode"
 	"github.com/ava-labs/coreth/trie/triestate"
@@ -118,9 +117,6 @@ type StateDB struct {
 
 	// Per-transaction access list
 	accessList *accessList
-	// Ordered storage slots to be used in predicate verification as set in the tx access list.
-	// Only set in PrepareAccessList, and un-modified through execution.
-	predicateStorageSlots map[common.Address][][]byte
 
 	// Transient storage
 	transientStorage transientStorage
@@ -173,24 +169,23 @@ func NewWithSnapshot(root common.Hash, db Database, snap snapshot.Snapshot) (*St
 		return nil, err
 	}
 	sdb := &StateDB{
-		db:                    db,
-		trie:                  tr,
-		originalRoot:          root,
-		accounts:              make(map[common.Hash][]byte),
-		storages:              make(map[common.Hash]map[common.Hash][]byte),
-		accountsOrigin:        make(map[common.Address][]byte),
-		storagesOrigin:        make(map[common.Address]map[common.Hash][]byte),
-		stateObjects:          make(map[common.Address]*stateObject),
-		stateObjectsPending:   make(map[common.Address]struct{}),
-		stateObjectsDirty:     make(map[common.Address]struct{}),
-		stateObjectsDestruct:  make(map[common.Address]*types.StateAccount),
-		logs:                  make(map[common.Hash][]*types.Log),
-		preimages:             make(map[common.Hash][]byte),
-		journal:               newJournal(),
-		predicateStorageSlots: make(map[common.Address][][]byte),
-		accessList:            newAccessList(),
-		transientStorage:      newTransientStorage(),
-		hasher:                crypto.NewKeccakState(),
+		db:                   db,
+		trie:                 tr,
+		originalRoot:         root,
+		accounts:             make(map[common.Hash][]byte),
+		storages:             make(map[common.Hash]map[common.Hash][]byte),
+		accountsOrigin:       make(map[common.Address][]byte),
+		storagesOrigin:       make(map[common.Address]map[common.Hash][]byte),
+		stateObjects:         make(map[common.Address]*stateObject),
+		stateObjectsPending:  make(map[common.Address]struct{}),
+		stateObjectsDirty:    make(map[common.Address]struct{}),
+		stateObjectsDestruct: make(map[common.Address]*types.StateAccount),
+		logs:                 make(map[common.Hash][]*types.Log),
+		preimages:            make(map[common.Hash][]byte),
+		journal:              newJournal(),
+		accessList:           newAccessList(),
+		transientStorage:     newTransientStorage(),
+		hasher:               crypto.NewKeccakState(),
 	}
 	if snap != nil {
 		if snap.Root() != root {
@@ -771,19 +766,6 @@ func (s *StateDB) CreateAccount(addr common.Address) {
 	}
 }
 
-// copyPredicateStorageSlots creates a deep copy of the provided predicateStorageSlots map.
-func copyPredicateStorageSlots(predicateStorageSlots map[common.Address][][]byte) map[common.Address][][]byte {
-	res := make(map[common.Address][][]byte, len(predicateStorageSlots))
-	for address, predicates := range predicateStorageSlots {
-		copiedPredicates := make([][]byte, len(predicates))
-		for i, predicateBytes := range predicates {
-			copiedPredicates[i] = common.CopyBytes(predicateBytes)
-		}
-		res[address] = copiedPredicates
-	}
-	return res
-}
-
 // Copy creates a deep, independent copy of the state.
 // Snapshots of the copied state cannot be applied to the copy.
 func (s *StateDB) Copy() *StateDB {
@@ -877,7 +859,6 @@ func (s *StateDB) Copy() *StateDB {
 	// in the middle of a transaction.
 	state.accessList = s.accessList.Copy()
 	state.transientStorage = s.transientStorage.Copy()
-	state.predicateStorageSlots = copyPredicateStorageSlots(s.predicateStorageSlots)
 
 	// If there's a prefetcher running, make an inactive copy of it that can
 	// only access data but does not actively preload (since the user will not
@@ -1442,8 +1423,6 @@ func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, d
 		if rules.IsDurango { // EIP-3651: warm coinbase
 			al.AddAddress(coinbase)
 		}
-
-		s.predicateStorageSlots = predicate.PreparePredicateStorageSlots(rules, list)
 	}
 	// Reset transient storage at the beginning of transaction execution
 	s.transientStorage = newTransientStorage()
@@ -1489,27 +1468,6 @@ func (s *StateDB) GetTxHash() common.Hash {
 	return s.thash
 }
 
-// GetPredicateStorageSlots returns the storage slots associated with the address, index pair.
-// A list of access tuples can be included within transaction types post EIP-2930. The address
-// is declared directly on the access tuple and the index is the i'th occurrence of an access
-// tuple with the specified address.
-//
-// Ex. AccessList[[AddrA, Predicate1], [AddrB, Predicate2], [AddrA, Predicate3]]
-// In this case, the caller could retrieve predicates 1-3 with the following calls:
-// GetPredicateStorageSlots(AddrA, 0) -> Predicate1
-// GetPredicateStorageSlots(AddrB, 0) -> Predicate2
-// GetPredicateStorageSlots(AddrA, 1) -> Predicate3
-func (s *StateDB) GetPredicateStorageSlots(address common.Address, index int) ([]byte, bool) {
-	predicates, exists := s.predicateStorageSlots[address]
-	if !exists {
-		return nil, false
-	}
-	if index >= len(predicates) {
-		return nil, false
-	}
-	return predicates[index], true
-}
-
 // convertAccountSet converts a provided account set from address keyed to hash keyed.
 func (s *StateDB) convertAccountSet(set map[common.Address]*types.StateAccount) map[common.Hash]struct{} {
 	ret := make(map[common.Hash]struct{}, len(set))
@@ -1524,11 +1482,6 @@ func (s *StateDB) convertAccountSet(set map[common.Address]*types.StateAccount)
 	return ret
 }
 
-// SetPredicateStorageSlots sets the predicate storage slots for the given address
-func (s *StateDB) SetPredicateStorageSlots(address common.Address, predicates [][]byte) {
-	s.predicateStorageSlots[address] = predicates
-}
-
 // copySet returns a deep-copied set.
 func copySet[k comparable](set map[k][]byte) map[k][]byte {
 	copied := make(map[k][]byte, len(set))

core/state_processor.go

@@ -32,6 +32,7 @@ import (
 	"math/big"
 
 	"github.com/ava-labs/coreth/consensus"
+	"github.com/ava-labs/coreth/core/extstate"
 	"github.com/ava-labs/coreth/core/state"
 	"github.com/ava-labs/coreth/core/types"
 	"github.com/ava-labs/coreth/core/vm"
@@ -242,7 +243,8 @@ func ApplyPrecompileActivations(c *params.ChainConfig, parentTimestamp *uint64,
 				// can be called from within Solidity contracts. Solidity adds a check before invoking a contract to ensure
 				// that it does not attempt to invoke a non-existent contract.
 				statedb.SetCode(module.Address, []byte{0x1})
-				if err := module.Configure(c, activatingConfig, statedb, blockContext); err != nil {
+				extstatedb := &extstate.StateDB{StateDB: statedb}
+				if err := module.Configure(c, activatingConfig, extstatedb, blockContext); err != nil {
 					return fmt.Errorf("could not configure precompile, name: %s, reason: %w", module.ConfigKey, err)
 				}
 			}