Merge branch 'merge-v1.14.4' into merge-v1.14.5

Author: amsanghi

arbitrum/recordingdb.go

@@ -32,17 +32,19 @@ type RecordingKV struct {
 	inner         *triedb.Database
 	diskDb        ethdb.KeyValueStore
 	readDbEntries map[common.Hash][]byte
+	mutex         sync.Mutex
 	enableBypass  bool
 }
 
 func newRecordingKV(inner *triedb.Database, diskDb ethdb.KeyValueStore) *RecordingKV {
-	return &RecordingKV{inner, diskDb, make(map[common.Hash][]byte), false}
+	return &RecordingKV{inner, diskDb, make(map[common.Hash][]byte), sync.Mutex{}, false}
 }
 
 func (db *RecordingKV) Has(key []byte) (bool, error) {
 	return false, errors.New("recording KV doesn't support Has")
 }
 
+// Get may be called concurrently with other Get calls
 func (db *RecordingKV) Get(key []byte) ([]byte, error) {
 	var hash common.Hash
 	var res []byte
@@ -66,6 +68,8 @@ func (db *RecordingKV) Get(key []byte) ([]byte, error) {
 	if crypto.Keccak256Hash(res) != hash {
 		return nil, fmt.Errorf("recording KV attempted to access non-hash key %v", hash)
 	}
+	db.mutex.Lock()
+	defer db.mutex.Unlock()
 	db.readDbEntries[hash] = res
 	return res, nil
 }

common/lru/blob_lru.go

@@ -82,3 +82,21 @@ func (c *SizeConstrainedCache[K, V]) Get(key K) (V, bool) {
 
 	return c.lru.Get(key)
 }
+
+func (c *SizeConstrainedCache[K, V]) Remove(key K) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	if v, ok := c.lru.Peek(key); ok {
+		c.size -= uint64(len(v))
+		c.lru.Remove(key)
+	}
+}
+
+func (c *SizeConstrainedCache[K, V]) Clear() {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	c.lru.Purge()
+	c.size = 0
+}

core/state/statedb.go

@@ -18,7 +18,6 @@
 package state
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"maps"
@@ -208,6 +207,18 @@ func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error)
 	return sdb, nil
 }
 
+func (s *StateDB) FilterTx() {
+	s.arbExtraData.arbTxFilter = true
+}
+
+func (s *StateDB) ClearTxFilter() {
+	s.arbExtraData.arbTxFilter = false
+}
+
+func (s *StateDB) IsTxFiltered() bool {
+	return s.arbExtraData.arbTxFilter
+}
+
 // SetLogger sets the logger for account update hooks.
 func (s *StateDB) SetLogger(l *tracing.Hooks) {
 	s.logger = l
@@ -718,6 +729,7 @@ func (s *StateDB) Copy() *StateDB {
 			recentWasms:            s.arbExtraData.recentWasms.Copy(),
 			openWasmPages:          s.arbExtraData.openWasmPages,
 			everWasmPages:          s.arbExtraData.everWasmPages,
+			arbTxFilter:            s.arbExtraData.arbTxFilter,
 		},
 
 		db:                   s.db,
@@ -898,32 +910,15 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 		// later time.
 		workers.SetLimit(1)
 	}
-	if s.deterministic {
-		addressesToUpdate := make([]common.Address, 0, len(s.mutations))
-		for addr := range s.mutations {
-			addressesToUpdate = append(addressesToUpdate, addr)
-		}
-		sort.Slice(addressesToUpdate, func(i, j int) bool { return bytes.Compare(addressesToUpdate[i][:], addressesToUpdate[j][:]) < 0 })
-		for _, addr := range addressesToUpdate {
-			if obj := s.mutations[addr]; !obj.applied && !obj.isDelete() {
-				obj := s.stateObjects[addr] // closure for the task runner below
-				workers.Go(func() error {
-					obj.updateRoot()
-					return nil
-				})
-			}
-		}
-	} else {
-		for addr, op := range s.mutations {
-			if op.applied || op.isDelete() {
-				continue
-			}
-			obj := s.stateObjects[addr] // closure for the task runner below
-			workers.Go(func() error {
-				obj.updateRoot()
-				return nil
-			})
+	for addr, op := range s.mutations {
+		if op.applied || op.isDelete() {
+			continue
 		}
+		obj := s.stateObjects[addr] // closure for the task runner below
+		workers.Go(func() error {
+			obj.updateRoot()
+			return nil
+		})
 	}
 	workers.Wait()
 	s.StorageUpdates += time.Since(start)
@@ -968,6 +963,9 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 		}
 		usedAddrs = append(usedAddrs, common.CopyBytes(addr[:])) // Copy needed for closure
 	}
+	if s.deterministic {
+		sort.Slice(deletedAddrs, func(i, j int) bool { return deletedAddrs[i].Cmp(deletedAddrs[j]) < 0 })
+	}
 	for _, deletedAddr := range deletedAddrs {
 		s.deleteStateObject(deletedAddr)
 		s.AccountDeleted += 1
@@ -1182,6 +1180,9 @@ func (s *StateDB) GetTrie() Trie {
 // commit gathers the state mutations accumulated along with the associated
 // trie changes, resetting all internal flags with the new state as the base.
 func (s *StateDB) commit(deleteEmptyObjects bool) (*stateUpdate, error) {
+	if s.arbExtraData.arbTxFilter {
+		return nil, ErrArbTxFilter
+	}
 	// Short circuit in case any database failure occurred earlier.
 	if s.dbErr != nil {
 		return nil, fmt.Errorf("commit aborted due to earlier error: %v", s.dbErr)
@@ -1326,7 +1327,7 @@ func (s *StateDB) commit(deleteEmptyObjects bool) (*stateUpdate, error) {
 
 	origin := s.originalRoot
 	s.originalRoot = root
-	return newStateUpdate(origin, root, deletes, updates, nodes), nil
+	return newStateUpdate(origin, root, deletes, updates, nodes, s.arbExtraData.activatedWasms), nil
 }
 
 // commitAndFlush is a wrapper of commit which also commits the state mutations
@@ -1347,10 +1348,10 @@ func (s *StateDB) commitAndFlush(block uint64, deleteEmptyObjects bool) (*stateU
 		}
 	}
 
-	if db := s.db.WasmStore(); db != nil && len(s.arbExtraData.activatedWasms) > 0 {
+	if db := s.db.WasmStore(); db != nil && len(ret.activatedWasms) > 0 {
 		batch := db.NewBatch()
 		// Arbitrum: write Stylus programs to disk
-		for moduleHash, asmMap := range s.arbExtraData.activatedWasms {
+		for moduleHash, asmMap := range ret.activatedWasms {
 			rawdb.WriteActivation(batch, moduleHash, asmMap)
 		}
 		s.arbExtraData.activatedWasms = make(map[common.Hash]ActivatedWasm)

core/state/statedb_arbitrum.go

@@ -164,13 +164,16 @@ func (s *StateDB) Deterministic() bool {
 	return s.deterministic
 }
 
+var ErrArbTxFilter error = errors.New("internal error")
+
 type ArbitrumExtraData struct {
 	unexpectedBalanceDelta *big.Int                      // total balance change across all accounts
 	userWasms              UserWasms                     // user wasms encountered during execution
 	openWasmPages          uint16                        // number of pages currently open
 	everWasmPages          uint16                        // largest number of pages ever allocated during this tx's execution
 	activatedWasms         map[common.Hash]ActivatedWasm // newly activated WASMs
 	recentWasms            RecentWasms
+	arbTxFilter            bool
 }
 
 func (s *StateDB) SetArbFinalizer(f func(*ArbitrumExtraData)) {

core/state/stateupdate.go

@@ -57,6 +57,7 @@ type stateUpdate struct {
 	storages       map[common.Hash]map[common.Hash][]byte    // storages stores mutated slots in 'prefix-zero-trimmed' RLP format
 	storagesOrigin map[common.Address]map[common.Hash][]byte // storagesOrigin stores the original values of mutated slots in 'prefix-zero-trimmed' RLP format
 	codes          map[common.Address]contractCode           // codes contains the set of dirty codes
+	activatedWasms map[common.Hash]ActivatedWasm             // newly activated WASMs
 	nodes          *trienode.MergedNodeSet                   // Aggregated dirty nodes caused by state changes
 }
 
@@ -68,7 +69,7 @@ func (sc *stateUpdate) empty() bool {
 // newStateUpdate constructs a state update object, representing the differences
 // between two states by performing state execution. It aggregates the given
 // account deletions and account updates to form a comprehensive state update.
-func newStateUpdate(originRoot common.Hash, root common.Hash, deletes map[common.Hash]*accountDelete, updates map[common.Hash]*accountUpdate, nodes *trienode.MergedNodeSet) *stateUpdate {
+func newStateUpdate(originRoot common.Hash, root common.Hash, deletes map[common.Hash]*accountDelete, updates map[common.Hash]*accountUpdate, nodes *trienode.MergedNodeSet, activatedWasms map[common.Hash]ActivatedWasm) *stateUpdate {
 	var (
 		destructs      = make(map[common.Hash]struct{})
 		accounts       = make(map[common.Hash][]byte)
@@ -128,6 +129,7 @@ func newStateUpdate(originRoot common.Hash, root common.Hash, deletes map[common
 		storages:       storages,
 		storagesOrigin: storagesOrigin,
 		codes:          codes,
+		activatedWasms: activatedWasms,
 		nodes:          nodes,
 	}
 }

core/state_transition.go

@@ -530,7 +530,7 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	} else {
 		fee := new(uint256.Int).SetUint64(st.gasUsed())
 		fee.Mul(fee, effectiveTipU256)
-		st.state.AddBalance(st.evm.Context.Coinbase, fee, tracing.BalanceIncreaseRewardTransactionFee)
+		st.state.AddBalance(tipReceipient, fee, tracing.BalanceIncreaseRewardTransactionFee)
 		tipAmount = fee.ToBig()
 		// add the coinbase to the witness iff the fee is greater than 0
 		if rules.IsEIP4762 && fee.Sign() != 0 {

core/types/transaction.go

@@ -64,15 +64,54 @@ type Transaction struct {
 	inner TxData    // Consensus contents of a transaction
 	time  time.Time // Time first seen locally (spam avoidance)
 
-	// Arbitrum cache: must be atomically accessed
-	CalldataUnits uint64
+	// Arbitrum cache of the calldata units at a brotli compression level.
+	// The top 8 bits are the brotli compression level last used to compute this,
+	// and the remaining 56 bits are the calldata units at that compression level.
+	calldataUnitsForBrotliCompressionLevel atomic.Uint64
 
 	// caches
 	hash atomic.Pointer[common.Hash]
 	size atomic.Uint64
 	from atomic.Pointer[sigCache]
 }
 
+// GetRawCachedCalldataUnits returns the cached brotli compression level and corresponding calldata units,
+// or (0, 0) if the cache is empty.
+func (tx *Transaction) GetRawCachedCalldataUnits() (uint64, uint64) {
+	repr := tx.calldataUnitsForBrotliCompressionLevel.Load()
+	cachedCompressionLevel := repr >> 56
+	calldataUnits := repr & ((1 << 56) - 1)
+	return cachedCompressionLevel, calldataUnits
+}
+
+// GetCachedCalldataUnits returns the cached calldata units for a given brotli compression level,
+// returning nil if no cache is present or the cache is for a different compression level.
+func (tx *Transaction) GetCachedCalldataUnits(requestedCompressionLevel uint64) *uint64 {
+	cachedCompressionLevel, cachedUnits := tx.GetRawCachedCalldataUnits()
+	if cachedUnits == 0 {
+		// empty cache
+		return nil
+	}
+	if cachedCompressionLevel != requestedCompressionLevel {
+		// wrong compression level
+		return nil
+	}
+	return &cachedUnits
+}
+
+// SetCachedCalldataUnits sets the cached brotli compression level and corresponding calldata units,
+// or clears the cache if the values are too large to fit (at least 2**8 and 2**56 respectively).
+// Note that a zero calldataUnits is also treated as an empty cache.
+func (tx *Transaction) SetCachedCalldataUnits(compressionLevel uint64, calldataUnits uint64) {
+	var repr uint64
+	// Ensure the compressionLevel and calldataUnits will fit.
+	// Otherwise, just clear the cache.
+	if compressionLevel < 1<<8 && calldataUnits < 1<<56 {
+		repr = compressionLevel<<56 | calldataUnits
+	}
+	tx.calldataUnitsForBrotliCompressionLevel.Store(repr)
+}
+
 // NewTx creates a new transaction.
 func NewTx(inner TxData) *Transaction {
 	tx := new(Transaction)

core/types/transaction_arbitrum_test.go

@@ -0,0 +1,49 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+import "testing"
+
+func TestTxCalldataUnitsCache(t *testing.T) {
+	tx := &Transaction{}
+	units := tx.GetCachedCalldataUnits(0)
+	if units != nil {
+		t.Errorf("unexpected initial cache present %v for compression 0", units)
+	}
+	units = tx.GetCachedCalldataUnits(1)
+	if units != nil {
+		t.Errorf("unexpected initial cache present %v for compression 1", units)
+	}
+	tx.SetCachedCalldataUnits(200, 1000)
+	units = tx.GetCachedCalldataUnits(100)
+	if units != nil {
+		t.Errorf("unexpected cached units %v present for incorrect compression 100", units)
+	}
+	units = tx.GetCachedCalldataUnits(0)
+	if units != nil {
+		t.Errorf("unexpected cached units %v present for incorrect compression 0", units)
+	}
+	units = tx.GetCachedCalldataUnits(200)
+	if units == nil || *units != 1000 {
+		t.Errorf("unexpected cached units %v for correct compression 200", units)
+	}
+	tx.SetCachedCalldataUnits(1, 1<<60)
+	units = tx.GetCachedCalldataUnits(1)
+	if units != nil {
+		t.Errorf("unexpected cache value %v present after reset", units)
+	}
+}

core/vm/instructions_arbitrum.go

@@ -49,6 +49,11 @@ type StateDB interface {
 	// Arbitrum: preserve old empty account behavior
 	CreateZombieIfDeleted(common.Address)
 
+	// Arbitrum
+	FilterTx()
+	ClearTxFilter()
+	IsTxFiltered() bool
+
 	Deterministic() bool
 	Database() state.Database
 

core/vm/interface.go

@@ -3,6 +3,7 @@ package pebble
 import "time"
 
 type ExtraOptions struct {
+	SyncMode                    bool
 	BytesPerSync                int
 	L0CompactionFileThreshold   int
 	L0CompactionThreshold       int