refactor: WithUNSAFEForceDelegate() replaces WithCaller()

Author: ARR4N

core/vm/contracts.libevm.go

@@ -220,22 +220,23 @@ func (args *evmCallArgs) Call(addr common.Address, input []byte, gas uint64, val
 	// methods to pass to [EVMInterpreter.Run], which are then propagated by the
 	// *CALL* opcodes as the caller.
 	precompile := NewContract(args.caller, AccountRef(args.self()), args.value, args.gas)
-	if args.delegation == delegated {
-		precompile = precompile.AsDelegate()
-	}
-	var caller ContractRef = precompile
 
+	asDelegate := args.delegation == delegated // precompile was DELEGATECALLed
 	for _, o := range opts {
 		switch o := o.(type) {
-		case withCallerOpt:
-			caller = o.ContractRef
+		case callOptForceDelegate:
+			// See documentation of [WithUNSAFEForceDelegate].
+			asDelegate = true
 		case nil:
 		default:
 			return nil, gas, fmt.Errorf("unsupported option %T", o)
 		}
 	}
+	if asDelegate {
+		precompile = precompile.AsDelegate()
+	}
 
-	return args.evm.Call(caller, addr, input, gas, value)
+	return args.evm.Call(precompile, addr, input, gas, value)
 }
 
 var (

core/vm/options.libevm.go

@@ -21,13 +21,16 @@ type CallOption interface {
 	libevmCallOption() // noop to only allow internally defined options
 }
 
-// WithCaller overrides the default caller.
-func WithCaller(c ContractRef) CallOption {
-	return withCallerOpt{c}
+// WithUNSAFEForceDelegate results in precompiles making contract calls acting
+// as if they themselves were DELEGATECALLed. This is not safe for regular use
+// as the precompile will act as its own caller even when not expected to.
+//
+// Deprecated: this option MUST NOT be used other than to allow migration to
+// libevm when backwards compatibility is required.
+func WithUNSAFEForceDelegate() CallOption {
+	return callOptForceDelegate{}
 }
 
-type withCallerOpt struct {
-	ContractRef
-}
+type callOptForceDelegate struct{}
 
-func (withCallerOpt) libevmCallOption() {}
+func (callOptForceDelegate) libevmCallOption() {}