Upgrade to go-ethereum v1.15.5 (#615)

* Update usage of medusa-geth API to support v1.15.5

* fix json file

Author: anishnaik

chain/standard_cheat_code_contract.go

@@ -340,7 +340,7 @@ func getStandardCheatCodeContract(tracer *cheatCodeTracer) (*CheatCodeContract,
 		func(tracer *cheatCodeTracer, inputs []any) ([]any, *cheatCodeRawReturnData) {
 			account := inputs[0].(common.Address)
 			nonce := inputs[1].(uint64)
-			tracer.chain.State().SetNonce(account, nonce)
+			tracer.chain.State().SetNonce(account, nonce, tracing.NonceChangeUnspecified)
 			return nil, nil
 		},
 	)
@@ -359,9 +359,9 @@ func getStandardCheatCodeContract(tracer *cheatCodeTracer) (*CheatCodeContract,
 				// We can cast OpContext to ScopeContext because that is the type passed to OnOpcode.
 				scopeContext := prankCallFrame.vmScope.(*vm.ScopeContext)
 				original := scopeContext.Caller()
-				scopeContext.Contract.CallerAddress = inputs[0].(common.Address)
+				scopeContext.Contract.SetCaller(inputs[0].(common.Address))
 				prankCallFrame.onFrameExitRestoreHooks.Push(func() {
-					scopeContext.Contract.CallerAddress = original
+					scopeContext.Contract.SetCaller(original)
 				})
 			})
 			return nil, nil
@@ -380,9 +380,9 @@ func getStandardCheatCodeContract(tracer *cheatCodeTracer) (*CheatCodeContract,
 			// We can cast OpContext to ScopeContext because that is the type passed to OnOpcode.
 			scopeContext := cheatCodeCallerFrame.vmScope.(*vm.ScopeContext)
 			original := scopeContext.Caller()
-			scopeContext.Contract.CallerAddress = inputs[0].(common.Address)
+			scopeContext.Contract.SetCaller(inputs[0].(common.Address))
 			cheatCodeCallerFrame.onFrameExitRestoreHooks.Push(func() {
-				scopeContext.Contract.CallerAddress = original
+				scopeContext.Contract.SetCaller(original)
 			})
 			return nil, nil
 		},
@@ -473,14 +473,14 @@ func getStandardCheatCodeContract(tracer *cheatCodeTracer) (*CheatCodeContract,
 			// Determine if this is a delegatecall.
 			isPrankedDelegateCall := false
 			if prankData.delegateCall {
-				if scopeContext.Contract.CodeAddr != nil && *scopeContext.Contract.CodeAddr != prankCallFrame.vmScope.Address() {
+				if scopeContext.Contract.Address() != prankCallFrame.vmScope.Address() {
 					isPrankedDelegateCall = true
 				}
 			}
 
 			// Store the original value and spoof our prank address.
 			originalMsgSender := scopeContext.Caller()
-			scopeContext.Contract.CallerAddress = prankData.msgSender
+			scopeContext.Contract.SetCaller(prankData.msgSender)
 
 			// Spoof the CodeAddress if we're pranking a delegatecall now.
 			originalCodeAddress := scopeContext.Contract.Address()
@@ -504,7 +504,7 @@ func getStandardCheatCodeContract(tracer *cheatCodeTracer) (*CheatCodeContract,
 				}
 
 				// Restore msg.sender and, if delegatecall flag enabled, code address
-				scopeContext.Contract.CallerAddress = originalMsgSender
+				scopeContext.Contract.SetCaller(originalMsgSender)
 				if isPrankedDelegateCall {
 					// TODO: Restore CodeAddress
 					_ = originalCodeAddress

chain/state/factories.go

@@ -50,7 +50,7 @@ type VanillaStateDbFactory struct {
 }
 
 func (v VanillaStateDbFactory) New(root common.Hash, db state.Database) (types.MedusaStateDB, error) {
-	return state.New(root, db, nil)
+	return state.New(root, db)
 }
 
 func NewVanillaStateFactory() *VanillaStateDbFactory {

chain/state/factories_test.go

@@ -1,74 +1,68 @@
 package state
 
 import (
+	"github.com/crytic/medusa/chain/state/cache"
 	"testing"
 
 	"github.com/crytic/medusa-geth/common"
-	"github.com/crytic/medusa-geth/core/rawdb"
 	gethstate "github.com/crytic/medusa-geth/core/state"
 	"github.com/crytic/medusa-geth/core/tracing"
 	"github.com/crytic/medusa-geth/core/types"
-	"github.com/crytic/medusa-geth/triedb"
-	"github.com/crytic/medusa/chain/state/cache"
 	types2 "github.com/crytic/medusa/chain/types"
 	"github.com/holiman/uint256"
 	"github.com/stretchr/testify/assert"
 )
 
-/* TestForkedStateDB provides unit testing for medusa-geth's ForkedStateDb */
+// TestForkedStateDB provides unit testing for medusa-geth's ForkedStateDb
 func TestForkedStateDB(t *testing.T) {
 	fixture := newPrePopulatedBackendFixture()
 	factory := NewForkedStateFactory(fixture.Backend)
 
-	db := rawdb.NewMemoryDatabase()
-	tdb := triedb.NewDatabase(db, nil)
-	cachingDb := gethstate.NewDatabaseWithNodeDB(db, tdb)
+	cachingDb := gethstate.NewDatabaseForTesting()
 
 	stateDb1, err := factory.New(types.EmptyRootHash, cachingDb)
 	assert.NoError(t, err)
 	genesisSnap := stateDb1.Snapshot()
 
-	/* ensure the statedb is hitting the backend */
+	// ensure the statedb is hitting the backend
 	assert.True(t, stateDb1.Exist(fixture.StateObjectContractAddress))
 	assert.True(t, stateDb1.Exist(fixture.StateObjectEOAAddress))
 	assert.False(t, stateDb1.Exist(fixture.StateObjectEmptyAddress))
 
 	fixture.verifyAgainstState(t, stateDb1)
 
-	/* write some new data and make sure it's readable */
+	// write some new data and make sure it's readable
 	newAccount := common.BytesToAddress([]byte{1, 2, 3, 4, 5, 6})
 	newAccountData := cache.StateObject{
 		Balance: uint256.NewInt(5),
 		Nonce:   99,
 		Code:    []byte{1, 2, 3},
 	}
 
-	stateDb1.SetNonce(newAccount, newAccountData.Nonce)
+	stateDb1.SetNonce(newAccount, newAccountData.Nonce, tracing.NonceChangeUnspecified)
 	assert.True(t, stateDb1.Exist(newAccount))
 	stateDb1.SetCode(newAccount, newAccountData.Code)
 	stateDb1.SetBalance(newAccount, newAccountData.Balance, tracing.BalanceChangeUnspecified)
 	checkAccountAgainstFixture(t, stateDb1, newAccount, newAccountData)
 
-	/* roll back to snapshot, ensure fork data still queryable and newly added data was purged */
+	// roll back to snapshot, ensure fork data still queryable and newly added data was purged
 	stateDb1.Snapshot()
 	stateDb1.RevertToSnapshot(genesisSnap)
 	fixture.verifyAgainstState(t, stateDb1)
 	assert.False(t, stateDb1.Exist(newAccount))
 
-	/* now we want to test to verify our fork-populated data is being persisted */
-	root, err := stateDb1.Commit(1, true)
+	// now we want to test to verify our fork-populated data is being persisted
+	root, err := stateDb1.Commit(1, true, true)
 	assert.NoError(t, err)
 	stateDb2, err := factory.New(root, cachingDb)
 	assert.NoError(t, err)
 
 	fixture.verifyAgainstState(t, stateDb2)
 }
 
-/*
-TestForkedStateFactory verifies the various independence/shared properties of each forkedStateDB created by the
-factory. This is because the underlying RPC/caching layer is shared between all TestChain instances globally,
-but this sharing relationship should not cause state to leak from one forkedStateDb to another.
-*/
+// TestForkedStateFactory verifies the various independence/shared properties of each forkedStateDB created by the
+// factory. This is because the underlying RPC/caching layer is shared between all TestChain instances globally,
+// but this sharing relationship should not cause state to leak from one forkedStateDb to another.
 func TestForkedStateFactory(t *testing.T) {
 	fixture := newPrePopulatedBackendFixture()
 	factory := NewForkedStateFactory(fixture.Backend)
@@ -81,7 +75,7 @@ func TestForkedStateFactory(t *testing.T) {
 	assert.NoError(t, err)
 	stateDb2.Snapshot()
 
-	/* naive check to ensure they're both pulling from the same remote */
+	// naive check to ensure they're both pulling from the same remote
 	fixture.verifyAgainstState(t, stateDb1)
 	fixture.verifyAgainstState(t, stateDb2)
 
@@ -91,7 +85,7 @@ func TestForkedStateFactory(t *testing.T) {
 	stateDb1.RevertToSnapshot(0)
 	stateDb2.RevertToSnapshot(0)
 
-	/* now we'll mutate a cold account in one stateDB and ensure the mutation doesn't propagate */
+	// now we'll mutate a cold account in one stateDB and ensure the mutation doesn't propagate
 	valueAdded := uint256.NewInt(100)
 	expectedSum := uint256.NewInt(0).Add(fixture.StateObjectEOA.Balance, valueAdded)
 	stateDb1.AddBalance(fixture.StateObjectEOAAddress, valueAdded, tracing.BalanceChangeUnspecified)
@@ -108,10 +102,8 @@ func TestForkedStateFactory(t *testing.T) {
 	bal = stateDb3.GetBalance(fixture.StateObjectEOAAddress)
 	assert.Equal(t, bal, fixture.StateObjectEOA.Balance)
 
-	/*
-		now we'll emulate one stateDB obtaining a new piece of data from RPC and ensuring the other stateDB loads
-		the same data
-	*/
+	// now we'll emulate one stateDB obtaining a new piece of data from RPC and ensuring the other stateDB loads
+	// the same data
 	newAccount := common.BytesToAddress([]byte{1, 2, 3, 4, 5, 6})
 	slotKey := common.BytesToHash([]byte{5, 5, 5, 5, 5, 5, 5})
 	slotData := common.BytesToHash([]byte{6, 6, 6, 6, 6, 6, 6})
@@ -127,10 +119,8 @@ func TestForkedStateFactory(t *testing.T) {
 	assert.EqualValues(t, slotData, data)
 }
 
-/*
-TestEmptyBackendFactoryDifferential tests the differential properties between a stateDB using an empty forked backend
-versus directly using geth's statedb.
-*/
+// TestEmptyBackendFactoryDifferential tests the differential properties between a stateDB using an empty forked backend
+// versus directly using geth's statedb.
 func TestEmptyBackendFactoryDifferential(t *testing.T) {
 	gethFactory := &gethStateFactory{}
 	unbackedFactory := NewUnbackedStateFactory()
@@ -141,14 +131,14 @@ func TestEmptyBackendFactoryDifferential(t *testing.T) {
 	unbackedStateDb, err := createEmptyStateDb(unbackedFactory)
 	assert.NoError(t, err)
 
-	/* start with existence/empty of an existing object. should be identical. */
+	// start with existence/empty of an existing object. should be identical.
 	addr := common.BytesToAddress([]byte{1})
-	gethStateDb.SetNonce(addr, 5)
-	unbackedStateDb.SetNonce(addr, 5)
+	gethStateDb.SetNonce(addr, 5, tracing.NonceChangeUnspecified)
+	unbackedStateDb.SetNonce(addr, 5, tracing.NonceChangeUnspecified)
 	assert.EqualValues(t, gethStateDb.Exist(addr), unbackedStateDb.Exist(addr))
 	assert.EqualValues(t, gethStateDb.Empty(addr), unbackedStateDb.Empty(addr))
 
-	/* existence/empty of a non-existing object, should be identical. */
+	// existence/empty of a non-existing object, should be identical.
 	nonExistentStateObjAddr := common.BytesToAddress([]byte{5, 5, 5, 5, 5})
 	assert.EqualValues(t, gethStateDb.Exist(nonExistentStateObjAddr), unbackedStateDb.Exist(nonExistentStateObjAddr))
 	assert.EqualValues(t, gethStateDb.Empty(nonExistentStateObjAddr), unbackedStateDb.Empty(nonExistentStateObjAddr))
@@ -158,19 +148,17 @@ func TestEmptyBackendFactoryDifferential(t *testing.T) {
 	gethStateDb.SetBalance(emptyStateObjectAddr, value, tracing.BalanceChangeUnspecified)
 	unbackedStateDb.SetBalance(emptyStateObjectAddr, value, tracing.BalanceChangeUnspecified)
 
-	/* existence/empty of an empty object, should be identical. */
+	// existence/empty of an empty object, should be identical.
 	gethStateDb.SubBalance(emptyStateObjectAddr, value, tracing.BalanceChangeUnspecified)
 	unbackedStateDb.SubBalance(emptyStateObjectAddr, value, tracing.BalanceChangeUnspecified)
 	assert.EqualValues(t, gethStateDb.Exist(emptyStateObjectAddr), unbackedStateDb.Exist(emptyStateObjectAddr))
 	assert.EqualValues(t, gethStateDb.Empty(emptyStateObjectAddr), unbackedStateDb.Empty(emptyStateObjectAddr))
 }
 
-/*
-TestForkedBackendDifferential tests the differential properties between a stateDB using a forked backend
-versus directly using geth's statedb. Consider this test a canonical definition of how our forked stateDB acts
-differently from geth's.
-Good place for future fuzz testing if we run into issues.
-*/
+// TestForkedBackendDifferential tests the differential properties between a stateDB using a forked backend
+// versus directly using geth's statedb. Consider this test a canonical definition of how our forked stateDB acts
+// differently from geth's.
+// Good place for future fuzz testing if we run into issues.
 func TestForkedBackendDifferential(t *testing.T) {
 	fixture := newPrePopulatedBackendFixture()
 	factory := NewForkedStateFactory(fixture.Backend)
@@ -187,14 +175,14 @@ func TestForkedBackendDifferential(t *testing.T) {
 		fixture.StateObjectContractAddress,
 		fixture.StateObjectContract.Balance,
 		tracing.BalanceChangeUnspecified)
-	gethStateDb.SetNonce(fixture.StateObjectContractAddress, fixture.StateObjectContract.Nonce)
+	gethStateDb.SetNonce(fixture.StateObjectContractAddress, fixture.StateObjectContract.Nonce, tracing.NonceChangeUnspecified)
 	gethStateDb.SetCode(fixture.StateObjectContractAddress, fixture.StateObjectContract.Code)
 	// eoa
 	gethStateDb.SetBalance(
 		fixture.StateObjectEOAAddress,
 		fixture.StateObjectEOA.Balance,
 		tracing.BalanceChangeUnspecified)
-	gethStateDb.SetNonce(fixture.StateObjectEOAAddress, fixture.StateObjectEOA.Nonce)
+	gethStateDb.SetNonce(fixture.StateObjectEOAAddress, fixture.StateObjectEOA.Nonce, tracing.NonceChangeUnspecified)
 	// do not set the empty account. On a live geth node, the empty account will be pruned.
 
 	// check exist/empty equivalence for the contract account
@@ -232,9 +220,7 @@ func TestForkedBackendDifferential(t *testing.T) {
 
 // createEmptyStateDb creates an empty stateDB using the provided factory. Intended for tests only.
 func createEmptyStateDb(factory MedusaStateFactory) (types2.MedusaStateDB, error) {
-	db := rawdb.NewMemoryDatabase()
-	tdb := triedb.NewDatabase(db, nil)
-	cachingDb := gethstate.NewDatabaseWithNodeDB(db, tdb)
+	cachingDb := gethstate.NewDatabaseForTesting()
 	return factory.New(types.EmptyRootHash, cachingDb)
 }
 
@@ -243,5 +229,5 @@ func createEmptyStateDb(factory MedusaStateFactory) (types2.MedusaStateDB, error
 type gethStateFactory struct{}
 
 func (f *gethStateFactory) New(root common.Hash, db gethstate.Database) (types2.MedusaStateDB, error) {
-	return gethstate.New(root, db, nil)
+	return gethstate.New(root, db)
 }

chain/test_chain.go

@@ -30,6 +30,8 @@ import (
 	"github.com/crytic/medusa/utils"
 )
 
+var _, MAX_UINT_64 = utils.GetIntegerConstraints(false, 64)
+
 // TestChain represents a simulated Ethereum chain used for testing. It maintains blocks in-memory and strips away
 // typical consensus/chain objects to allow for more specialized testing closer to the EVM.
 type TestChain struct {
@@ -148,14 +150,17 @@ func newTestChainWithStateFactory(
 		return nil, err
 	}
 
-	// TODO: go-ethereum doesn't set cancun start time for THEIR test `ChainConfig` struct.
+	// TODO: go-ethereum doesn't set prague start time for THEIR test `ChainConfig` struct.
 	//   Note: We have our own `TestChainConfig` definition that is different (second argument in this function).
 	//  We should allow the user to provide a go-ethereum `ChainConfig` to do custom fork selection, inside of our
 	//  `TestChainConfig` definition. Or we should wrap it in our own struct to simplify the options and not pollute
 	//  our overall medusa project config.
-	cancunTime := uint64(0)
-	chainConfig.ShanghaiTime = &cancunTime
-	chainConfig.CancunTime = &cancunTime
+	pragueTime := uint64(0)
+	chainConfig.PragueTime = &pragueTime
+	chainConfig.ShanghaiTime = &pragueTime
+	chainConfig.CancunTime = &pragueTime
+	// Set the default blob schedule
+	chainConfig.BlobScheduleConfig = params.DefaultBlobSchedule
 
 	// Create our genesis definition with our default chain config.
 	genesisDefinition := &core.Genesis{
@@ -215,7 +220,7 @@ func newTestChainWithStateFactory(
 	// Convert our genesis block (go-ethereum type) to a test chain block.
 	testChainGenesisBlock := types.NewBlock(genesisBlock.Header())
 	// Create our state database over-top our database.
-	stateDatabase := gethState.NewDatabaseWithConfig(db, dbConfig)
+	stateDatabase := gethState.NewDatabase(trieDB, nil)
 
 	// Create a tracer forwarder to support the addition of multiple tracers for transaction and call execution.
 	transactionTracerRouter := NewTestChainTracerRouter()
@@ -252,10 +257,8 @@ func newTestChainWithStateFactory(
 	if err != nil {
 		return nil, err
 	}
-
-	// Set our state database logger e.g. to monitor OnCodeChange events.
-	stateDB.SetLogger(transactionTracerRouter.NativeTracer().Tracer.Hooks)
 	chain.state = stateDB
+
 	return chain, nil
 }
 
@@ -511,8 +514,7 @@ func (t *TestChain) CallContract(msg *core.Message, state types.MedusaStateDB, a
 	// Set infinite balance to the fake caller account
 	state.SetBalance(msg.From, uint256.MustFromBig(math.MaxBig256), tracing.BalanceChangeUnspecified)
 
-	// Create our transaction and block contexts for the vm
-	txContext := core.NewEVMTxContext(msg)
+	// Create our block contexts for the vm
 	blockContext := newTestChainBlockContext(t, t.Head().Header)
 
 	// Create a new call tracer router that incorporates any additional tracers provided just for this call, while
@@ -522,11 +524,12 @@ func (t *TestChain) CallContract(msg *core.Message, state types.MedusaStateDB, a
 	extendedTracerRouter.AddTracers(additionalTracers...)
 
 	// Create our EVM instance.
-	evm := vm.NewEVM(blockContext, txContext, state, t.chainConfig, vm.Config{
+	evm := vm.NewEVM(blockContext, state, t.chainConfig, vm.Config{
 		Tracer:           extendedTracerRouter.NativeTracer().Tracer.Hooks,
 		NoBaseFee:        true,
 		ConfigExtensions: t.vmConfigExtensions,
 	})
+
 	// Set our block context and chain config in order for cheatcodes to override what EVM interpreter sees.
 	t.pendingBlockContext = &evm.Context
 	t.pendingBlockChainConfig = evm.ChainConfig()
@@ -539,7 +542,8 @@ func (t *TestChain) CallContract(msg *core.Message, state types.MedusaStateDB, a
 		evm.Config.Tracer.OnTxStart(evm.GetVMContext(), tx, msg.From)
 	}
 	// Fund the gas pool, so it can execute endlessly (no block gas limit).
-	gasPool := new(core.GasPool).AddGas(math.MaxUint64)
+
+	gasPool := new(core.GasPool).AddGas(MAX_UINT_64.Uint64())
 
 	// Perform our state transition to obtain the result.
 	msgResult, err := core.ApplyMessage(evm, msg, gasPool)
@@ -705,7 +709,7 @@ func (t *TestChain) PendingBlockAddTx(message *core.Message, additionalTracers .
 	t.state.SetTxContext(tx.Hash(), len(t.pendingBlock.Messages))
 
 	// Create our EVM instance.
-	evm := vm.NewEVM(blockContext, core.NewEVMTxContext(message), t.state, t.chainConfig, vmConfig)
+	evm := vm.NewEVM(blockContext, t.state, t.chainConfig, vmConfig)
 
 	// Set our block context and chain config in order for cheatcodes to override what EVM interpreter sees.
 	t.pendingBlockContext = &evm.Context
@@ -765,7 +769,7 @@ func (t *TestChain) PendingBlockCommit() error {
 	}
 
 	// Perform a state commit to obtain the root hash for our block.
-	root, err := t.state.Commit(t.pendingBlock.Header.Number.Uint64(), true)
+	root, err := t.state.Commit(t.pendingBlock.Header.Number.Uint64(), true, true)
 	t.pendingBlock.Header.Root = root
 
 	if err != nil {