fix: vm.WithUNSAFECallerAddressProxying under DELEGATECALL (#50)

* fix: `vm.WithUNSAFECallerAddressProxying` under `DELEGATECALL`

* test: `vm.WithUNSAFECallerAddressProxying()` effect on outgoing caller addr

* chore: mark `eth/tracers/js` test flaky

* feat: `vm.PrecompileEnvironment.IncomingCallType()`

* chore: minor documentation edit

* doc: `PrecompileEnvironment` example for determining actual caller

* chore: placate the linter

Author: ARR4N

.github/workflows/go.yml

@@ -18,6 +18,6 @@ jobs:
           go-version: 1.21.4
       - name: Run tests
         run: | # Upstream flakes are race conditions exacerbated by concurrent tests
-          FLAKY_REGEX='go-ethereum/(eth|eth/tracers/logger|accounts/keystore|eth/downloader|miner|ethclient|ethclient/gethclient|eth/catalyst)$';
+          FLAKY_REGEX='go-ethereum/(eth|eth/tracers/js|eth/tracers/logger|accounts/keystore|eth/downloader|miner|ethclient|ethclient/gethclient|eth/catalyst)$';
           go list ./... | grep -P "${FLAKY_REGEX}" | xargs -n 1 go test -short;
           go test -short $(go list ./... | grep -Pv "${FLAKY_REGEX}");

core/vm/contracts.libevm.go

@@ -42,7 +42,7 @@ import (
 //	    args := &evmCallArgs{evm, staticCall, caller, addr, input, gas, nil /*value*/}
 type evmCallArgs struct {
 	evm      *EVM
-	callType callType
+	callType CallType
 
 	// args:start
 	caller ContractRef
@@ -53,15 +53,32 @@ type evmCallArgs struct {
 	// args:end
 }
 
-type callType uint8
+// A CallType refers to a *CALL* [OpCode] / respective method on [EVM].
+type CallType uint8
 
 const (
-	call callType = iota + 1
-	callCode
-	delegateCall
-	staticCall
+	UnknownCallType CallType = iota
+	Call
+	CallCode
+	DelegateCall
+	StaticCall
 )
 
+// String returns a human-readable representation of the CallType.
+func (t CallType) String() string {
+	switch t {
+	case Call:
+		return "Call"
+	case CallCode:
+		return "CallCode"
+	case DelegateCall:
+		return "DelegateCall"
+	case StaticCall:
+		return "StaticCall"
+	}
+	return fmt.Sprintf("Unknown %T(%d)", t, t)
+}
+
 // run runs the [PrecompiledContract], differentiating between stateful and
 // regular types.
 func (args *evmCallArgs) run(p PrecompiledContract, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error) {
@@ -115,6 +132,7 @@ type PrecompileEnvironment interface {
 	// ReadOnlyState will always be non-nil.
 	ReadOnlyState() libevm.StateReader
 	Addresses() *libevm.AddressContext
+	IncomingCallType() CallType
 
 	BlockHeader() (types.Header, error)
 	BlockNumber() *big.Int
@@ -132,46 +150,30 @@ func (args *evmCallArgs) env() *environment {
 		value = args.value
 	)
 	switch args.callType {
-	case staticCall:
+	case StaticCall:
 		value = new(uint256.Int)
 		fallthrough
-	case call:
+	case Call:
 		self = args.addr
 
-	case delegateCall:
+	case DelegateCall:
 		value = nil
 		fallthrough
-	case callCode:
+	case CallCode:
 		self = args.caller.Address()
 	}
 
 	// This is equivalent to the `contract` variables created by evm.*Call*()
 	// methods, for non precompiles, to pass to [EVMInterpreter.Run].
 	contract := NewContract(args.caller, AccountRef(self), value, args.gas)
-	if args.callType == delegateCall {
+	if args.callType == DelegateCall {
 		contract = contract.AsDelegate()
 	}
 
 	return &environment{
-		evm:           args.evm,
-		self:          contract,
-		forceReadOnly: args.readOnly(),
-	}
-}
-
-func (args *evmCallArgs) readOnly() bool {
-	// A switch statement provides clearer code coverage for difficult-to-test
-	// cases.
-	switch {
-	case args.callType == staticCall:
-		// evm.interpreter.readOnly is only set to true via a call to
-		// EVMInterpreter.Run() so, if a precompile is called directly with
-		// StaticCall(), then readOnly might not be set yet.
-		return true
-	case args.evm.interpreter.readOnly:
-		return true
-	default:
-		return false
+		evm:      args.evm,
+		self:     contract,
+		callType: args.callType,
 	}
 }