Fix transfer prestate trace

eth/tracers/internal/tracers/prestate_tracer.js

@@ -47,6 +47,12 @@
 	// result is invoked when all the opcodes have been iterated over and returns
 	// the final result of the tracing.
 	result: function(ctx, db) {
+		if (this.prestate === null) {
+			this.prestate = {};
+			// If tx is transfer-only, the recipient account
+			// hasn't been populated.
+			this.lookupAccount(ctx.to, db);
+		}
 		// At this point, we need to deduct the 'value' from the
 		// outer transaction, and move it back to the origin
 		this.lookupAccount(ctx.from, db);
@@ -79,7 +85,7 @@
 		}
 		// Whenever new state is accessed, add it to the prestate
 		switch (log.op.toString()) {
-			case "EXTCODECOPY": case "EXTCODESIZE": case "BALANCE":
+			case "EXTCODECOPY": case "EXTCODESIZE": case "EXTCODEHASH": case "BALANCE":
 				this.lookupAccount(toAddress(log.stack.peek(0).toString(16)), db);
 				break;
 			case "CREATE":

eth/tracers/tracers_test.go

@@ -201,6 +201,73 @@ func TestPrestateTracerCreate2(t *testing.T) {
 	}
 }
 
+func TestPrestateTracerTransfer(t *testing.T) {
+	celoMock := testutil.NewCeloMock()
+
+	toAddr := "0x00000000000000000000000000000000deadbeef"
+	unsignedTx := types.NewTransaction(1, common.HexToAddress(toAddr), new(big.Int), 5000000, big.NewInt(1), nil, nil, nil, []byte{})
+
+	privateKeyECDSA, err := ecdsa.GenerateKey(crypto.S256(), rand.Reader)
+	if err != nil {
+		t.Fatalf("err %v", err)
+	}
+	signer := types.NewEIP155Signer(big.NewInt(1))
+	tx, err := types.SignTx(unsignedTx, signer, privateKeyECDSA)
+	if err != nil {
+		t.Fatalf("err %v", err)
+	}
+	origin, _ := signer.Sender(tx)
+	txContext := vm.TxContext{
+		Origin:   origin,
+		GasPrice: big.NewInt(1),
+	}
+	context := vm.BlockContext{
+		CanTransfer:          vmcontext.CanTransfer,
+		Transfer:             vmcontext.TobinTransfer,
+		Coinbase:             common.Address{},
+		BlockNumber:          new(big.Int).SetUint64(8000000),
+		Time:                 new(big.Int).SetUint64(5),
+		GetRegisteredAddress: vmcontext.GetRegisteredAddress,
+	}
+	alloc := core.GenesisAlloc{}
+	alloc[origin] = core.GenesisAccount{
+		Nonce:   1,
+		Code:    []byte{},
+		Balance: big.NewInt(500000000000000),
+	}
+	_, statedb := tests.MakePreState(rawdb.NewMemoryDatabase(), alloc, false)
+
+	// Create the tracer, the EVM environment and run it
+	tracer, err := New("prestateTracer", new(Context))
+	if err != nil {
+		t.Fatalf("failed to create prestate tracer: %v", err)
+	}
+	vmConfig := vm.Config{Debug: true, Tracer: tracer}
+	evm := vm.NewEVM(context, txContext, statedb, params.MainnetChainConfig, vmConfig)
+
+	msg, err := tx.AsMessage(signer, nil)
+	if err != nil {
+		t.Fatalf("failed to prepare transaction for tracing: %v", err)
+	}
+
+	st := core.NewStateTransition(evm, msg, new(core.GasPool).AddGas(tx.Gas()), celoMock.Runner, nil)
+	if _, err = st.TransitionDb(); err != nil {
+		t.Fatalf("failed to execute transaction: %v", err)
+	}
+	// Retrieve the trace result and compare against the etalon
+	res, err := tracer.GetResult()
+	if err != nil {
+		t.Fatalf("failed to retrieve trace result: %v", err)
+	}
+	ret := make(map[string]interface{})
+	if err := json.Unmarshal(res, &ret); err != nil {
+		t.Fatalf("failed to unmarshal trace result: %v", err)
+	}
+	if _, has := ret[toAddr]; !has {
+		t.Fatalf("Expected %s in result", toAddr)
+	}
+}
+
 // Iterates over all the input-output datasets in the tracer test harness and
 // runs the JavaScript tracers against them.
 func TestCallTracerLegacy(t *testing.T) {