Add test cases for native and precompile transfers and tracing (#2077)

* Add callTracer API test cases for native and precompile transfers

* Add e2e test for calling GoldToken.transfer

* Add comment explaining GoldToken transfer e2e test

* Fix nits in transferPrecompile var and comments

* Fix bug in precompile length checking

* Rename ValueTransferTransaction to BuildSignedTransaction

* Keep TransferAddress private for now and address PR comments

Author: Eela Nagaraj

core/vm/contracts.go

@@ -698,7 +698,7 @@ func (c *transfer) Run(input []byte, caller common.Address, evm *EVM) ([]byte, e
 	//   to:    32 bytes representing the address of the recipient
 	//   value: 32 bytes, a 256 bit integer representing the amount of Celo Gold to transfer
 	// 3 arguments x 32 bytes each = 96 bytes total input
-	if (evm.chainRules.IsGFork && len(input) != 96) || len(input) <= 96 {
+	if (evm.chainRules.IsGFork && len(input) != 96) || len(input) < 96 {
 		return nil, ErrInputLength
 	}
 

e2e_test/e2e_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/celo-org/celo-blockchain/common"
 	"github.com/celo-org/celo-blockchain/common/hexutil"
 	"github.com/celo-org/celo-blockchain/core/types"
+	"github.com/celo-org/celo-blockchain/eth/tracers"
 	"github.com/celo-org/celo-blockchain/log"
 	"github.com/celo-org/celo-blockchain/node"
 	"github.com/celo-org/celo-blockchain/rpc"
@@ -55,6 +56,41 @@ func TestSendCelo(t *testing.T) {
 	require.NoError(t, err)
 }
 
+// This test starts a network, submits a GoldToken.transfer tx, waits for the whole
+// network to process the transaction, and traces that tx.
+// This tests that CELO transfers made via the transfer precompile work e2e
+// and can be useful for debugging these traces.
+func TestTraceSendCeloViaGoldToken(t *testing.T) {
+	ac := test.AccountConfig(3, 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 1 wei of CELO from accounts[0] to accounts[1] by calling GoldToken.transfer
+	tx, err := accounts[0].SendCeloViaGoldToken(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)
+	// Check top level gas values
+	require.Equal(t, result["gasUsed"], "0x3a46")
+	require.Equal(t, result["gas"], "0x3ac4")
+}
+
 // This test verifies correct behavior in a network of size one, in the case that
 // this fails we know that the problem does not lie with our network code.
 func TestSingleNodeNetworkManyTxs(t *testing.T) {

eth/tracers/api_test.go

@@ -29,6 +29,7 @@ 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"
@@ -544,6 +545,194 @@ 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()
 

test/account.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/celo-org/celo-blockchain/common"
 	"github.com/celo-org/celo-blockchain/core/types"
+	"github.com/celo-org/celo-blockchain/mycelo/contract"
 	"github.com/celo-org/celo-blockchain/mycelo/env"
 	"github.com/celo-org/celo-blockchain/params"
 )
@@ -44,14 +45,16 @@ func (a *Account) SendCelo(ctx context.Context, recipient common.Address, value
 	}
 
 	signer := types.MakeSigner(a.ChainConfig, new(big.Int).SetUint64(num))
-	tx, err := ValueTransferTransaction(
+	tx, err := BuildSignedTransaction(
 		node.WsClient,
 		a.Key,
 		a.Address,
 		recipient,
 		*a.Nonce,
 		big.NewInt(value),
-		signer)
+		signer,
+		nil,
+	)
 
 	if err != nil {
 		return nil, err
@@ -118,6 +121,56 @@ func (a *Account) SendCeloTracked(ctx context.Context, recipient common.Address,
 	return node.Tracker.GetProcessedTx(tx.Hash()), nil
 }
 
+// SendCelo submits a transaction to `node` that invokes the equivalent of
+// GoldToken.transfer(recipient, value), sent from the calling account.
+// The submitted transaction is returned.
+func (a *Account) SendCeloViaGoldToken(ctx context.Context, recipient common.Address, value int64, node *Node) (*types.Transaction, error) {
+	var err error
+	// Lazy set nonce
+	if a.Nonce == nil {
+		a.Nonce = new(uint64)
+		*a.Nonce, err = node.WsClient.PendingNonceAt(ctx, a.Address)
+		if err != nil {
+			return nil, err
+		}
+	}
+	num, err := node.WsClient.BlockNumber(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	signer := types.MakeSigner(a.ChainConfig, new(big.Int).SetUint64(num))
+	goldTokenName := "GoldToken"
+	goldTokenProxyAddr, err := env.ProxyAddressFor(goldTokenName)
+	if err != nil {
+		return nil, err
+	}
+	goldTokenABI := contract.AbiFor(goldTokenName)
+	data, err := goldTokenABI.Pack("transfer", recipient, big.NewInt(value))
+	if err != nil {
+		return nil, err
+	}
+	tx, err := BuildSignedTransaction(
+		node.WsClient,
+		a.Key,
+		a.Address,
+		goldTokenProxyAddr,
+		*a.Nonce,
+		big.NewInt(0),
+		signer,
+		data,
+	)
+	if err != nil {
+		return nil, err
+	}
+	err = node.WsClient.SendTransaction(ctx, tx)
+	if err != nil {
+		return nil, err
+	}
+	*a.Nonce++
+	return tx, nil
+}
+
 // Accounts converts a slice of env.Account objects to Account objects.
 func Accounts(accts []env.Account, chainConfig *params.ChainConfig) []*Account {
 	accounts := make([]*Account, 0, len(accts))

test/node.go

@@ -477,17 +477,16 @@ func (n Network) Shutdown() []error {
 	return errors
 }
 
-// ValueTransferTransaction builds a signed value transfer transaction from the
-// sender to the recipient with the given value and nonce, it uses the client
-// to suggest a gas price and to estimate the gas.
-func ValueTransferTransaction(
+// Uses the client to suggest a gas price and to estimate the gas.
+func BuildSignedTransaction(
 	client *ethclient.Client,
 	senderKey *ecdsa.PrivateKey,
 	sender,
 	recipient common.Address,
 	nonce uint64,
 	value *big.Int,
 	signer types.Signer,
+	data []byte,
 ) (*types.Transaction, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
 	defer cancel()
@@ -497,14 +496,13 @@ func ValueTransferTransaction(
 		return nil, fmt.Errorf("failed to suggest gas price: %v", err)
 	}
 
-	msg := ethereum.CallMsg{From: sender, To: &recipient, GasPrice: gasPrice, Value: value}
+	msg := ethereum.CallMsg{From: sender, To: &recipient, GasPrice: gasPrice, Value: value, Data: data}
 	gasLimit, err := client.EstimateGas(ctx, msg)
 	if err != nil {
 		return nil, fmt.Errorf("failed to estimate gas needed: %v", err)
 	}
-
 	// Create the transaction and sign it
-	rawTx := types.NewTransactionEthCompatible(nonce, recipient, value, gasLimit, gasPrice, nil)
+	rawTx := types.NewTransactionEthCompatible(nonce, recipient, value, gasLimit, gasPrice, data)
 	signed, err := types.SignTx(rawTx, signer, senderKey)
 	if err != nil {
 		return nil, err