Merge remote-tracking branch 'origin/master' into valuegeneration-tracer

Author: s4nsec

.github/workflows/ci.yml

@@ -51,7 +51,7 @@ jobs:
 
       - uses: actions/setup-go@v5
         with:
-          go-version: "^1.18.1"
+          go-version: "^1.22"
           # disable caching during release (tag) builds
           cache: ${{ !startsWith(github.ref, 'refs/tags/') }}
 
@@ -129,7 +129,7 @@ jobs:
 
       - uses: actions/setup-go@v5
         with:
-          go-version: "^1.18.1"
+          go-version: "^1.22"
 
       - name: Actionlint
         run: |
@@ -156,6 +156,13 @@ jobs:
           go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
           golangci-lint run --timeout 5m0s
 
+      - name: Gencodec
+        run: |
+          go get github.com/fjl/gencodec 
+          pushd fuzzing/config
+          go run github.com/fjl/gencodec -type FuzzingConfig -field-override fuzzingConfigMarshaling -out gen_fuzzing_config.go
+          git diff --exit-code -- .
+          popd
   test:
     strategy:
       matrix:
@@ -197,7 +204,7 @@ jobs:
 
       - uses: actions/setup-go@v5
         with:
-          go-version: "^1.18.1"
+          go-version: "^1.22"
 
       - uses: actions/setup-node@v4
         with:

CODEOWNERS

@@ -1 +1 @@
-*                                  @Xenomega @anishnaik
+*                                  @Xenomega @anishnaik @0xalpharush

CONTRIBUTING.md

@@ -59,7 +59,7 @@ To install
 To run
 
 - `prettier '**.json' '**/*.md' '**/*.yml' '!(pkg)'`
-- `markdown-link-check --config .github/workflows/resources/markdown_link_check.json ./*.md`
+- `find . -name '*.md' -print0 | xargs -0 -n1 markdown-link-check --config .github/workflows/resources/markdown_link_check.json`
 
 To format (overwrite files)
 

chain/cheat_code_tracer.go

@@ -1,10 +1,14 @@
 package chain
 
 import (
+	"math/big"
+
 	"github.com/crytic/medusa/chain/types"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/tracing"
+	coretypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
-	"math/big"
+	"github.com/ethereum/go-ethereum/eth/tracers"
 )
 
 // cheatCodeTracer represents an EVM.Logger which tracks and patches EVM execution state to enable extended
@@ -18,13 +22,16 @@ type cheatCodeTracer struct {
 	callDepth uint64
 
 	// evm refers to the EVM instance last captured.
-	evm *vm.EVM
+	evmContext *tracing.VMContext
 
 	// callFrames represents per-call-frame data deployment information being captured by the tracer.
 	callFrames []*cheatCodeTracerCallFrame
 
 	// results stores the tracer output after a transaction has concluded.
 	results *cheatCodeTracerResults
+
+	// nativeTracer is the underlying tracer interface that the cheatcode tracer follows
+	nativeTracer *TestChainTracer
 }
 
 // cheatCodeTracerCallFrame represents per-call-frame data traced by a cheatCodeTracer.
@@ -57,13 +64,14 @@ type cheatCodeTracerCallFrame struct {
 	// vmOp describes the current call frame's last instruction executed.
 	vmOp vm.OpCode
 	// vmScope describes the current call frame's scope context.
-	vmScope *vm.ScopeContext
+	vmScope tracing.OpContext
 	// vmReturnData describes the current call frame's return data (set on exit).
 	vmReturnData []byte
 	// vmErr describes the current call frame's returned error (set on exit), nil if no error.
 	vmErr error
 }
 
+// cheatCodeTracerResults holds the hooks that need to be executed when the chain reverts.
 type cheatCodeTracerResults struct {
 	// onChainRevertHooks describes hooks which are to be executed when the chain reverts.
 	onChainRevertHooks types.GenericHookFuncs
@@ -72,9 +80,25 @@ type cheatCodeTracerResults struct {
 // newCheatCodeTracer creates a cheatCodeTracer and returns it.
 func newCheatCodeTracer() *cheatCodeTracer {
 	tracer := &cheatCodeTracer{}
+	innerTracer := &tracers.Tracer{
+		Hooks: &tracing.Hooks{
+			OnTxStart: tracer.OnTxStart,
+			OnTxEnd:   tracer.OnTxEnd,
+			OnEnter:   tracer.OnEnter,
+			OnExit:    tracer.OnExit,
+			OnOpcode:  tracer.OnOpcode,
+		},
+	}
+	tracer.nativeTracer = &TestChainTracer{Tracer: innerTracer, CaptureTxEndSetAdditionalResults: tracer.CaptureTxEndSetAdditionalResults}
+
 	return tracer
 }
 
+// NativeTracer returns the underlying TestChainTracer.
+func (t *cheatCodeTracer) NativeTracer() *TestChainTracer {
+	return t.nativeTracer
+}
+
 // bindToChain is called by the TestChain which created the tracer to set its reference.
 // Note: This is done because of the cheat code system's dependency on the genesis block, as well as chain's dependency
 // on it, which prevents the chain being set in the tracer on initialization.
@@ -98,115 +122,105 @@ func (t *cheatCodeTracer) CurrentCallFrame() *cheatCodeTracerCallFrame {
 	return t.callFrames[t.callDepth]
 }
 
-// CaptureTxStart is called upon the start of transaction execution, as defined by vm.EVMLogger.
-func (t *cheatCodeTracer) CaptureTxStart(gasLimit uint64) {
+// OnTxStart is called upon the start of transaction execution, as defined by tracers.Tracer.
+func (t *cheatCodeTracer) OnTxStart(vm *tracing.VMContext, tx *coretypes.Transaction, from common.Address) {
 	// Reset our capture state
 	t.callDepth = 0
 	t.callFrames = make([]*cheatCodeTracerCallFrame, 0)
 	t.results = &cheatCodeTracerResults{
 		onChainRevertHooks: nil,
 	}
+	// Store our evm reference
+	t.evmContext = vm
 }
 
-// CaptureTxEnd is called upon the end of transaction execution, as defined by vm.EVMLogger.
-func (t *cheatCodeTracer) CaptureTxEnd(restGas uint64) {
+// OnTxEnd is called upon the end of transaction execution, as defined by tracers.Tracer
+func (t *cheatCodeTracer) OnTxEnd(*coretypes.Receipt, error) {
 
 }
 
-// CaptureStart initializes the tracing operation for the top of a call frame, as defined by vm.EVMLogger.
-func (t *cheatCodeTracer) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
-	// Store our evm reference
-	t.evm = env
+// OnEnter initializes the tracing operation for the top of a call frame, as defined by tracers.Tracer.
+func (t *cheatCodeTracer) OnEnter(depth int, typ byte, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+	// Check to see if this is the top level call frame
+	isTopLevelFrame := depth == 0
+	var callFrameData *cheatCodeTracerCallFrame
+	if isTopLevelFrame {
+		// Create our call frame struct to track data for this initial entry call frame.
+		callFrameData = &cheatCodeTracerCallFrame{}
+	} else {
+		// We haven't updated our call depth yet, so obtain the "previous" call frame (current for now)
+		previousCallFrame := t.CurrentCallFrame()
+
+		// Create our call frame struct to track data for this initial entry call frame.
+		// We forward our "next frame hooks" to this frame, then clear them from the previous frame.
+		callFrameData = &cheatCodeTracerCallFrame{
+			onFrameExitRestoreHooks: previousCallFrame.onNextFrameExitRestoreHooks,
+		}
+		previousCallFrame.onNextFrameExitRestoreHooks = nil
+
+		// Increase our call depth now that we're entering a new call frame.
+		t.callDepth++
+	}
 
-	// Create our call frame struct to track data for this initial entry call frame.
-	callFrameData := &cheatCodeTracerCallFrame{}
+	// Append our new call frame
 	t.callFrames = append(t.callFrames, callFrameData)
+
+	// Note: We do not execute events for "next frame enter" here, as we do not yet have scope information.
+	// Those events are executed when the first EVM instruction is executed in the new scope.
 }
 
-// CaptureEnd is called after a call to finalize tracing completes for the top of a call frame, as defined by vm.EVMLogger.
-func (t *cheatCodeTracer) CaptureEnd(output []byte, gasUsed uint64, err error) {
+// OnExit is called after a call to finalize tracing completes for the top of a call frame, as defined by tracers.Tracer.
+func (t *cheatCodeTracer) OnExit(depth int, output []byte, gasUsed uint64, err error, reverted bool) {
 	// Execute all current call frame exit hooks
 	exitingCallFrame := t.callFrames[t.callDepth]
 	exitingCallFrame.onFrameExitRestoreHooks.Execute(false, true)
-	exitingCallFrame.onTopFrameExitRestoreHooks.Execute(false, true)
 
-	// If we didn't encounter an error in this call frame, we push our upward propagating revert events up one frame.
-	if err == nil {
-		// Store these revert hooks in our results.
-		t.results.onChainRevertHooks = append(t.results.onChainRevertHooks, exitingCallFrame.onChainRevertRestoreHooks...)
+	var parentCallFrame *cheatCodeTracerCallFrame
+	if depth == 0 {
+		// If this is the top-level call frame, execute all of its exit hooks
+		exitingCallFrame.onTopFrameExitRestoreHooks.Execute(false, true)
 	} else {
-		// We hit an error, so a revert occurred before this tx was committed.
-		exitingCallFrame.onChainRevertRestoreHooks.Execute(false, true)
+		// If not, retrieve the parent call frame
+		parentCallFrame = t.callFrames[t.callDepth-1]
 	}
 
 	// We're exiting the current frame, so remove our frame data.
 	t.callFrames = t.callFrames[:t.callDepth]
-}
-
-// CaptureEnter is called upon entering of the call frame, as defined by vm.EVMLogger.
-func (t *cheatCodeTracer) CaptureEnter(typ vm.OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
-	// We haven't updated our call depth yet, so obtain the "previous" call frame (current for now)
-	previousCallFrame := t.CurrentCallFrame()
 
-	// Increase our call depth now that we're entering a new call frame.
-	t.callDepth++
-
-	// Create our call frame struct to track data for this initial entry call frame.
-	// We forward our "next frame hooks" to this frame, then clear them from the previous frame.
-	callFrameData := &cheatCodeTracerCallFrame{
-		onFrameExitRestoreHooks: previousCallFrame.onNextFrameExitRestoreHooks,
-	}
-	previousCallFrame.onNextFrameExitRestoreHooks = nil
-	t.callFrames = append(t.callFrames, callFrameData)
-
-	// Note: We do not execute events for "next frame enter" here, as we do not yet have scope information.
-	// Those events are executed when the first EVM instruction is executed in the new scope.
-}
-
-// CaptureExit is called upon exiting of the call frame, as defined by vm.EVMLogger.
-func (t *cheatCodeTracer) CaptureExit(output []byte, gasUsed uint64, err error) {
-	// Execute all current call frame exit hooks
-	exitingCallFrame := t.callFrames[t.callDepth]
-	exitingCallFrame.onFrameExitRestoreHooks.Execute(false, true)
-	parentCallFrame := t.callFrames[t.callDepth-1]
-
-	// If we didn't encounter an error in this call frame, we push our upward propagating revert events up one frame.
-	if err == nil {
+	// If we didn't encounter an error in this call frame, we push our upward propagating restore events up one frame.
+	if err == nil && depth == 0 {
+		// Since this is the top call frame, we add the revert events to the results of the tracer and return early
+		t.results.onChainRevertHooks = append(t.results.onChainRevertHooks, exitingCallFrame.onChainRevertRestoreHooks...)
+		return
+	} else if err == nil {
+		// Propagate hooks up to the parent call frame
 		parentCallFrame.onTopFrameExitRestoreHooks = append(parentCallFrame.onTopFrameExitRestoreHooks, exitingCallFrame.onTopFrameExitRestoreHooks...)
 		parentCallFrame.onChainRevertRestoreHooks = append(parentCallFrame.onChainRevertRestoreHooks, exitingCallFrame.onChainRevertRestoreHooks...)
 	} else {
 		// We hit an error, so a revert occurred before this tx was committed.
 		exitingCallFrame.onChainRevertRestoreHooks.Execute(false, true)
 	}
 
-	// We're exiting the current frame, so remove our frame data.
-	t.callFrames = t.callFrames[:t.callDepth]
-
 	// Decrease our call depth now that we've exited a call frame.
 	t.callDepth--
 }
 
-// CaptureState records data from an EVM state update, as defined by vm.EVMLogger.
-func (t *cheatCodeTracer) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, vmErr error) {
+// OnOpcode records data from an EVM state update, as defined by tracers.Tracer.
+func (t *cheatCodeTracer) OnOpcode(pc uint64, op byte, gas, cost uint64, scope tracing.OpContext, rData []byte, depth int, err error) {
 	// Set our current frame information.
 	currentCallFrame := t.CurrentCallFrame()
 	currentCallFrame.vmPc = pc
-	currentCallFrame.vmOp = op
+	currentCallFrame.vmOp = vm.OpCode(op)
 	currentCallFrame.vmScope = scope
 	currentCallFrame.vmReturnData = rData
-	currentCallFrame.vmErr = vmErr
+	currentCallFrame.vmErr = err
 
 	// We execute our entered next frame hooks here (from our previous call frame), as we now have scope information.
 	if t.callDepth > 0 {
 		t.callFrames[t.callDepth-1].onNextFrameEnterHooks.Execute(true, true)
 	}
 }
 
-// CaptureFault records an execution fault, as defined by vm.EVMLogger.
-func (t *cheatCodeTracer) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error) {
-
-}
-
 // CaptureTxEndSetAdditionalResults can be used to set additional results captured from execution tracing. If this
 // tracer is used during transaction execution (block creation), the results can later be queried from the block.
 // This method will only be called on the added tracer if it implements the extended TestChainTracer interface.

chain/config/config.go

@@ -13,6 +13,9 @@ type TestChainConfig struct {
 
 	// CheatCodeConfig indicates the configuration for EVM cheat codes to use.
 	CheatCodeConfig CheatCodeConfig `json:"cheatCodes"`
+
+	// ContractAddressOverrides describes contracts that are going to be deployed at deterministic addresses
+	ContractAddressOverrides map[common.Hash]common.Address `json:"contractAddressOverrides,omitempty"`
 }
 
 // CheatCodeConfig describes any configuration options related to the use of vm extensions (a.k.a. cheat codes)
@@ -27,9 +30,16 @@ type CheatCodeConfig struct {
 
 // GetVMConfigExtensions derives a vm.ConfigExtensions from the provided TestChainConfig.
 func (t *TestChainConfig) GetVMConfigExtensions() *vm.ConfigExtensions {
-	// Obtain our cheat code precompiled contracts.
+	// Create a copy of the contract address overrides that can be ephemerally updated by medusa-geth
+	contractAddressOverrides := make(map[common.Hash]common.Address)
+	for hash, addr := range t.ContractAddressOverrides {
+		contractAddressOverrides[hash] = addr
+	}
+
+	// Obtain our vm config extensions data structure
 	return &vm.ConfigExtensions{
-		OverrideCodeSizeCheck: t.CodeSizeCheckDisabled,
-		AdditionalPrecompiles: make(map[common.Address]vm.PrecompiledContract),
+		OverrideCodeSizeCheck:    t.CodeSizeCheckDisabled,
+		AdditionalPrecompiles:    make(map[common.Address]vm.PrecompiledContract),
+		ContractAddressOverrides: contractAddressOverrides,
 	}
 }

chain/console_log_cheat_code_contract.go

@@ -1,10 +1,11 @@
 package chain
 
 import (
+	"strconv"
+
 	"github.com/crytic/medusa/utils"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
-	"strconv"
 )
 
 // ConsoleLogContractAddress is the address for the console.log precompile contract