Move API tracing tests to e2e

Author: Eela Nagaraj

e2e_test/e2e_test.go

@@ -2,6 +2,7 @@ package e2e_test
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"math/big"
@@ -93,6 +94,45 @@ func TestTraceSendCeloViaGoldToken(t *testing.T) {
 	// Check top level gas values
 	require.Equal(t, result["gasUsed"], "0x3a46")
 	require.Equal(t, result["gas"], "0x3ac4")
+	// TODO add more specific trace-checking as part of
+	// this issue: https://github.com/celo-org/celo-blockchain/issues/2078
+}
+
+// Moved from API tests because registering the callTracer (necessary after the
+// go native tracer refactor) causes a circular import.
+// Use the callTracer to trace a native CELO transfer.
+func TestCallTraceTransactionNativeTransfer(t *testing.T) {
+	ac := test.AccountConfig(1, 2)
+	gc, ec, err := test.BuildConfig(ac)
+	require.NoError(t, err)
+	network, shutdown, err := test.NewNetwork(ac, gc, ec)
+	require.NoError(t, err)
+	defer shutdown()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
+	defer cancel()
+
+	accounts := test.Accounts(ac.DeveloperAccounts(), gc.ChainConfig())
+
+	// Send one celo from external account 0 to 1 via node 0.
+	tx, err := accounts[0].SendCelo(ctx, accounts[1].Address, 1, network[0])
+	require.NoError(t, err)
+
+	// Wait for the whole network to process the transaction.
+	err = network.AwaitTransactions(ctx, tx)
+	require.NoError(t, err)
+	c, err := rpc.DialContext(ctx, network[0].WSEndpoint())
+	require.NoError(t, err)
+
+	var result map[string]interface{}
+	tracerStr := "callTracer"
+	err = c.CallContext(ctx, &result, "debug_traceTransaction", tx.Hash().String(), tracers.TraceConfig{Tracer: &tracerStr})
+	require.NoError(t, err)
+	res_json, err := json.Marshal(result)
+	if err != nil {
+		t.Fatalf("failed to marshal result: %v", err)
+	}
+	expectedTraceStr := fmt.Sprintf(`{"from":"0x%x","gas":"0x0","gasUsed":"0x0","input":"0x","output":"0x","to":"0x%x","type":"CALL","value":"0x1"}`, accounts[0].Address, accounts[1].Address)
+	require.JSONEq(t, expectedTraceStr, string(res_json))
 }
 
 // This test verifies correct behavior in a network of size one, in the case that

eth/tracers/api_test.go

@@ -29,7 +29,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/celo-org/celo-blockchain/accounts/abi"
 	"github.com/celo-org/celo-blockchain/common"
 	"github.com/celo-org/celo-blockchain/common/hexutil"
 	"github.com/celo-org/celo-blockchain/consensus"
@@ -404,194 +403,6 @@ func TestTraceTransactionWithRegistryDeployed(t *testing.T) {
 	}
 }
 
-// Use the callTracer to trace a native CELO transfer after the
-// registry has been deployed, as above.
-func TestCallTraceTransactionNativeTransfer(t *testing.T) {
-	t.Parallel()
-
-	// Initialize test accounts
-	accounts := newAccounts(2)
-	genesis := &core.Genesis{Alloc: core.GenesisAlloc{
-		accounts[0].addr: {Balance: big.NewInt(params.Ether)},
-		accounts[1].addr: {Balance: big.NewInt(params.Ether)},
-		common.HexToAddress("0xce10"): { // Registry Proxy
-			Code: testutil.RegistryProxyOpcodes,
-			Storage: map[common.Hash]common.Hash{
-				// Hashes represent the storage slot for Registry.sol's `registry` mapping
-				// which is stored in the RegistryProxy's storage.
-				// Hashes are computed by taking: keccack(packed(params.GoldTokenRegistryId, 1)),
-				// where 1 is the storage offset)
-				common.HexToHash("0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc"): common.HexToHash("0xce11"), // Registry Implementation
-				common.HexToHash("0x91646b8507bf2e54d7c3de9155442ba111546b81af1cbdd1f68eeb6926b98d58"): common.HexToHash("0xd023"), // Governance Proxy
-			},
-			Balance: big.NewInt(0),
-		},
-		common.HexToAddress("0xce11"): { // Registry Implementation
-			Code:    testutil.RegistryOpcodes,
-			Balance: big.NewInt(0),
-		},
-	}}
-
-	target := common.Hash{}
-	signer := types.HomesteadSigner{}
-	transferVal := big.NewInt(1000)
-	api := NewAPI(newTestBackend(t, 1, genesis, func(i int, b *core.BlockGen) {
-		// Transfer from account[0] to account[1]
-		//    value: 1000 wei
-		//    fee:   0 wei
-		tx, _ := types.SignTx(types.NewTransaction(uint64(i), accounts[1].addr, transferVal, params.TxGas, nil, nil, nil, nil, nil), signer, accounts[0].key)
-		b.AddTx(tx)
-		target = tx.Hash()
-	}))
-	tracerStr := "callTracer"
-	result, err := api.TraceTransaction(context.Background(), target, &TraceConfig{Tracer: &tracerStr})
-	if err != nil {
-		t.Errorf("Failed to trace transaction %v", err)
-	}
-
-	ret := new(callTrace)
-	if err := json.Unmarshal(result.(json.RawMessage), ret); err != nil {
-		t.Fatalf("failed to unmarshal trace result: %v", err)
-	}
-	expectedTrace := &callTrace{
-		Type:    "CALL",
-		From:    accounts[0].addr,
-		To:      accounts[1].addr,
-		Input:   hexutil.Bytes(common.Hex2Bytes("0x")),
-		Output:  hexutil.Bytes(common.Hex2Bytes("0x")),
-		Gas:     newRPCUint64(0),
-		GasUsed: newRPCUint64(0),
-		Value:   (*hexutil.Big)(transferVal),
-	}
-	if !jsonEqual(ret, expectedTrace) {
-		t.Fatalf("trace mismatch: \nhave %+v\nwant %+v", ret, expectedTrace)
-	}
-}
-
-// Use the callTracer to trace a CELO transfer made via the transfer
-// precompile (by sending this from the registered GoldToken contract).
-func TestCallTraceTransactionPrecompileTransfer(t *testing.T) {
-	// Invoke the transfer precompile by sending a transfer from an account
-	// registered as GoldToken in the mock registry
-	t.Parallel()
-	// Initialize test accounts
-	accounts := newAccounts(3)
-	goldToken := accounts[0]
-	registryProxyAddr := common.HexToAddress("0xce10")
-	registryImplAddr := common.HexToAddress("0xce11")
-	genesis := &core.Genesis{Alloc: core.GenesisAlloc{
-		goldToken.addr:   {Balance: big.NewInt(params.Ether)},
-		accounts[1].addr: {Balance: big.NewInt(params.Ether)},
-		accounts[2].addr: {Balance: big.NewInt(params.Ether)},
-		registryProxyAddr: { // Registry Proxy
-			Code: testutil.RegistryProxyOpcodes,
-			Storage: map[common.Hash]common.Hash{
-				common.HexToHash("0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc"): common.HexToHash("0xce11"), // Registry Implementation
-				common.HexToHash("0x91646b8507bf2e54d7c3de9155442ba111546b81af1cbdd1f68eeb6926b98d58"): common.HexToHash("0xd023"), // Governance Proxy
-				common.HexToHash("0x773cc8652456781771d48fb3d560d7ba3d6d1882654492b68beec583d2c590aa"): goldToken.addr.Hash(),      // GoldToken Implementation
-				common.HexToHash("0x2131a4338f6fb8d4507e234a7c72af8efefbbf2f1817ed570bce33eb6667feb9"): common.HexToHash("0xd007"), // Reserve Implementation
-			},
-			Balance: big.NewInt(0),
-		},
-		registryImplAddr: { // Registry Implementation
-			Code:    testutil.RegistryOpcodes,
-			Balance: big.NewInt(0),
-		},
-	}}
-
-	target := common.Hash{}
-	signer := types.HomesteadSigner{}
-	transferVal := big.NewInt(1000)
-
-	// Construct and pack data for transfer precompile representing [from, to, value]
-	addressTy, err := abi.NewType("address", "", nil)
-	if err != nil {
-		t.Fatalf("failed to create address type: %v", err)
-	}
-	uint256Ty, err := abi.NewType("uint256", "", nil)
-	if err != nil {
-		t.Fatalf("failed to create uint256 type: %v", err)
-	}
-
-	transferArgs := abi.Arguments{
-		{
-			Type: addressTy,
-		},
-		{
-			Type: addressTy,
-		},
-		{
-			Type: uint256Ty,
-		},
-	}
-	data, err := transferArgs.Pack(accounts[1].addr, accounts[2].addr, transferVal)
-	if err != nil {
-		t.Fatalf("failed to pack args: %v", err)
-	}
-	transferPrecompile := common.HexToAddress("0xfd")
-	gas := params.TxGas * 2
-	api := NewAPI(newTestBackend(t, 1, genesis, func(i int, b *core.BlockGen) {
-		// Transfer via transfer precompile by sending tx from GoldToken addr
-		tx, _ := types.SignTx(types.NewTransaction(uint64(i), transferPrecompile, big.NewInt(0), gas, big.NewInt(3), nil, nil, nil, data), signer, goldToken.key)
-		b.AddTx(tx)
-		target = tx.Hash()
-	}))
-	tracerStr := "callTracer"
-	result, err := api.TraceTransaction(context.Background(), target, &TraceConfig{Tracer: &tracerStr})
-
-	if err != nil {
-		t.Errorf("Failed to trace transaction %v", err)
-	}
-
-	ret := new(callTrace)
-	if err := json.Unmarshal(result.(json.RawMessage), ret); err != nil {
-		t.Fatalf("failed to unmarshal trace result: %v", err)
-	}
-
-	// Registry ABI packed version of Registry.getAddressFor("GoldToken")
-	packedGetAddressForGoldToken := common.FromHex("0xdd927233d7e89ade8430819f08bf97a087285824af3351ee12d72a2d132b0c6c0687bfaf")
-	expectedTrace := &callTrace{
-		// Outer transaction call
-		Type:   "CALL",
-		From:   goldToken.addr,
-		To:     transferPrecompile,
-		Input:  data,
-		Output: data,
-		Gas:    newRPCUint64(20112),
-		// Note that top-level traces do not currently include intrinsic gas
-		GasUsed: newRPCUint64(params.CallValueTransferGas),
-		Value:   (*hexutil.Big)(big.NewInt(0)),
-		Calls: []callTrace{
-			{
-				// Lookup of GoldToken contract address with capped gas
-				Type:    "STATICCALL",
-				From:    common.ZeroAddress,
-				To:      registryProxyAddr,
-				Input:   packedGetAddressForGoldToken,
-				Output:  common.LeftPadBytes(goldToken.addr.Bytes(), 32),
-				Gas:     newRPCUint64(params.MaxGasForGetAddressFor),
-				GasUsed: newRPCUint64(0),
-				Calls: []callTrace{
-					{
-						// RegistryProxy -> RegistryImpl delegate call to
-						// retrieve GoldToken address
-						Type:    "DELEGATECALL",
-						From:    registryProxyAddr,
-						To:      registryImplAddr,
-						Input:   packedGetAddressForGoldToken,
-						Output:  common.LeftPadBytes(goldToken.addr.Bytes(), 32),
-						Gas:     newRPCUint64(0),
-						GasUsed: newRPCUint64(0),
-					},
-				},
-			},
-		},
-	}
-	if !jsonEqual(ret, expectedTrace) {
-		t.Fatalf("trace mismatch: \nhave %+v\nwant %+v", ret, expectedTrace)
-	}
-}
-
 func TestTraceBlock(t *testing.T) {
 	t.Parallel()
 
@@ -905,11 +716,6 @@ func newRPCBalance(balance *big.Int) **hexutil.Big {
 	return &rpcBalance
 }
 
-func newRPCUint64(number uint64) *hexutil.Uint64 {
-	rpcUint64 := hexutil.Uint64(number)
-	return &rpcUint64
-}
-
 func newRPCBytes(bytes []byte) *hexutil.Bytes {
 	rpcBytes := hexutil.Bytes(bytes)
 	return &rpcBytes
@@ -925,23 +731,3 @@ func newStates(keys []common.Hash, vals []common.Hash) *map[common.Hash]common.H
 	}
 	return &m
 }
-
-// jsonEqual is similar to reflect.DeepEqual, but does a 'bounce' via json prior to
-// comparison
-// Note: this is duplicated from calltrace_test due to keep the diff minimal
-// after package restructuring in go-ethereum.
-func jsonEqual(x, y interface{}) bool {
-	xTrace := new(callTrace)
-	yTrace := new(callTrace)
-	if xj, err := json.Marshal(x); err == nil {
-		json.Unmarshal(xj, xTrace)
-	} else {
-		return false
-	}
-	if yj, err := json.Marshal(y); err == nil {
-		json.Unmarshal(yj, yTrace)
-	} else {
-		return false
-	}
-	return reflect.DeepEqual(xTrace, yTrace)
-}