sync: coreth PR #1301: fix: block hash when overriding to block n+1 (#1814)

Co-authored-by: Arran Schlosberg <519948+ARR4N@users.noreply.github.com>

Author: JonathanOppenheimer

eth/tracers/api.go

@@ -33,6 +33,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"math/big"
 	"os"
 	"runtime"
 	"sync"
@@ -959,17 +960,32 @@ func (api *API) TraceCall(ctx context.Context, args ethapi.TransactionArgs, bloc
 	}
 	defer release()
 
-	vmctx := core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+	h := block.Header()
+	blockContext := core.NewEVMBlockContext(h, api.chainContext(ctx), nil)
 
 	// Apply the customization rules if required.
 	if config != nil {
+		if config.BlockOverrides != nil && config.BlockOverrides.Number.ToInt().Uint64() == h.Number.Uint64()+1 {
+			// Overriding the block number to n+1 is a common way for wallets to
+			// simulate transactions, however without the following fix, a contract
+			// can assert it is being simulated by checking if blockhash(n) == 0x0 and
+			// can behave differently during the simulation. (#32175 for more info)
+			// --
+			// Modify the parent hash and number so that downstream, blockContext's
+			// GetHash function can correctly return n.
+			h.ParentHash = h.Hash()
+			h.Number.Add(h.Number, big.NewInt(1))
+		}
 		originalTime := block.Time()
-		config.BlockOverrides.Apply(&vmctx)
+		config.BlockOverrides.Apply(&blockContext)
 		// Apply all relevant upgrades from [originalTime] to the block time set in the override.
 		// Should be applied before the state overrides.
-		blockContext := core.NewBlockContext(vmctx.BlockNumber, vmctx.Time)
-		err = core.ApplyUpgrades(api.backend.ChainConfig(), &originalTime, blockContext, statedb)
-		if err != nil {
+		if err := core.ApplyUpgrades(
+			api.backend.ChainConfig(),
+			&originalTime,
+			core.NewBlockContext(block.Number(), block.Time()),
+			statedb,
+		); err != nil {
 			return nil, err
 		}
 
@@ -978,7 +994,7 @@ func (api *API) TraceCall(ctx context.Context, args ethapi.TransactionArgs, bloc
 		}
 	}
 	// Execute the trace
-	msg, err := args.ToMessage(api.backend.RPCGasCap(), vmctx.BaseFee)
+	msg, err := args.ToMessage(api.backend.RPCGasCap(), blockContext.BaseFee)
 	if err != nil {
 		return nil, err
 	}
@@ -987,7 +1003,7 @@ func (api *API) TraceCall(ctx context.Context, args ethapi.TransactionArgs, bloc
 	if config != nil {
 		traceConfig = &config.TraceConfig
 	}
-	return api.traceTx(ctx, msg, new(Context), vmctx, statedb, traceConfig)
+	return api.traceTx(ctx, msg, new(Context), blockContext, statedb, traceConfig)
 }
 
 // traceTx configures a new tracer according to the provided configuration, and

eth/tracers/api_extra_test.go

@@ -423,6 +423,9 @@ func testTraceCallWithOverridesStateUpgrade(t *testing.T, scheme string) {
 			expect:    `{"gas":21000,"failed":true,"returnValue":"","structLogs":[]}`,
 		},
 		{
+			// Test that state upgrades are NOT applied when only time is overridden.
+			// Even though we override time to after the state upgrade, the upgrade
+			// should not be applied because it uses the original block time.
 			blockNumber: rpc.BlockNumber(activateStateUpgradeBlock - 1),
 			call: ethapi.TransactionArgs{
 				From:  &accounts[2].addr,
@@ -431,11 +434,12 @@ func testTraceCallWithOverridesStateUpgrade(t *testing.T, scheme string) {
 			},
 			config: &TraceCallConfig{
 				BlockOverrides: &ethapi.BlockOverrides{
-					Time: (*hexutil.Uint64)(&fastForwardTime),
+					Number: (*hexutil.Big)(big.NewInt(int64(activateStateUpgradeBlock - 1))),
+					Time:   (*hexutil.Uint64)(&fastForwardTime),
 				},
 			},
-			expectErr: core.ErrInsufficientFunds,
-			expect:    `{"gas":21000,"failed":true,"returnValue":"","structLogs":[]}`,
+			expectErr: nil,
+			expect:    `{"gas":21000,"failed":false,"returnValue":"","structLogs":[]}`,
 		},
 	}
 	for i, testspec := range testSuite {

eth/tracers/api_test.go

@@ -928,6 +928,25 @@ func testTracingWithOverrides(t *testing.T, scheme string) {
 			},
 			want: `{"gas":25288,"failed":false,"returnValue":"0000000000000000000000000000000000000000000000000000000000000055"}`,
 		},
+		{ // Override blocknumber with block n+1 and query a blockhash (resolves issue #32175)
+			blockNumber: rpc.LatestBlockNumber,
+			call: ethapi.TransactionArgs{
+				From: &accounts[0].addr,
+				Input: newRPCBytes([]byte{
+					byte(vm.PUSH1), byte(genBlocks),
+					byte(vm.BLOCKHASH),
+					byte(vm.PUSH1), 0x00,
+					byte(vm.MSTORE),
+					byte(vm.PUSH1), 0x20,
+					byte(vm.PUSH1), 0x00,
+					byte(vm.RETURN),
+				}),
+			},
+			config: &TraceCallConfig{
+				BlockOverrides: &ethapi.BlockOverrides{Number: (*hexutil.Big)(big.NewInt(int64(genBlocks + 1)))},
+			},
+			want: fmt.Sprintf(`{"gas":59592,"failed":false,"returnValue":"%x"}`, backend.chain.GetHeaderByNumber(uint64(genBlocks)).Hash()),
+		},
 	}
 	for i, tc := range testSuite {
 		result, err := api.TraceCall(context.Background(), tc.call, rpc.BlockNumberOrHash{BlockNumber: &tc.blockNumber}, tc.config)