Merge remote-tracking branch 'upstream/master' into feature/go-native-trace

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 len(input) < 96 {
+	if (evm.chainRules.IsGFork && len(input) != 96) || len(input) < 96 {
 		return nil, ErrInputLength
 	}
 
@@ -781,7 +781,7 @@ func (c *fractionMulExp) Run(input []byte, caller common.Address, evm *EVM) ([]b
 	//   decimals:     32 bytes, 256 bit integer, places of precision
 	//
 	// 6 args x 32 bytes each = 192 bytes total input length
-	if len(input) < 192 {
+	if (evm.chainRules.IsGFork && len(input) != 192) || len(input) < 192 {
 		return nil, ErrInputLength
 	}
 
@@ -1015,7 +1015,7 @@ func (c *getValidator) Run(input []byte, caller common.Address, evm *EVM) ([]byt
 	// input is comprised of two arguments:
 	//   index: 32 byte integer representing the index of the validator to get
 	//   blockNumber: 32 byte integer representing the block number to access
-	if len(input) < 64 {
+	if (evm.chainRules.IsGFork && len(input) != 64) || len(input) < 64 {
 		return nil, ErrInputLength
 	}
 

core/vm/contracts_test.go

@@ -499,7 +499,14 @@ func BenchmarkPrecompiledEd25519Verify(b *testing.B) { benchJSON("ed25519Verify"
 
 // Tests sample inputs for fractionMulExp
 // NOTE: This currently only verifies that inputs of invalid length are rejected
-func TestPrecompiledFractionMulExp(t *testing.T) { testJSON("fractionMulExp", "fc", t) }
+func TestPrecompiledFractionMulExp(t *testing.T) {
+	// Post GFork behaviour
+	mockEVM.chainRules.IsGFork = true
+	testJSON("fractionMulExp", "fc", t)
+	// Pre GFork behaviour
+	mockEVM.chainRules.IsGFork = false
+	testJSON("fractionMulExpOld", "fc", t)
+}
 
 // Tests sample inputs for proofOfPossession
 // NOTE: This currently only verifies that inputs of invalid length are rejected

core/vm/testdata/precompiles/fractionMulExp.json

@@ -6,13 +6,14 @@
 	},
 	{
 		"Input": "0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000150000000000000000000000000000000000000000000000000000000000000f100000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000400000000",
-		"Expected": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002710",
-		"Name": "input_too_long"
+		"Expected": "invalid input length",
+		"Name": "input_too_long",
+		"ErrorExpected": true
 	},
 	{
 		"Input":         "",
 		"Expected":      "invalid input length",
 		"Name":          "empty_input",
 		"ErrorExpected": true
 	}
-]
+]

core/vm/testdata/precompiles/fractionMulExpOld.json

@@ -0,0 +1,7 @@
+[
+	{
+		"Input": "0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000150000000000000000000000000000000000000000000000000000000000000f100000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000400000000",
+		"Expected": "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002710",
+		"Name": "input_too_long"
+	}
+]

e2e_test/e2e_test.go

@@ -14,12 +14,17 @@ 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"
 	"github.com/celo-org/celo-blockchain/test"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	// Force-load native and js pacakges, to trigger registration
+	_ "github.com/celo-org/celo-blockchain/eth/tracers/js"
+	_ "github.com/celo-org/celo-blockchain/eth/tracers/native"
 )
 
 func init() {
@@ -55,6 +60,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/protocols/eth/handlers.go

@@ -137,6 +137,11 @@ func handleGetBlockBodies67(backend Backend, msg Decoder, peer *Peer) error {
 	return peer.ReplyBlockBodiesRLP(query.RequestId, response)
 }
 
+// In Celo the return value of the `GetBlockBodies` query has been changed to include both the block hash
+// and the block bodies. This is necessary because received block bodies can not be matched to the header
+// directly, as there is body data (i.e. `Randomness` and `EpochSnarkData`) which is not represented in the
+// header. That means that that the block fetcher cannot find the corresponding header for given blockdata
+// without executing the block contents. This is avoided by passing the block hash with the body data.
 func answerGetBlockBodiesQuery(backend Backend, query GetBlockBodiesPacket, peer *Peer) ([]rlp.RawValue, error) {
 	// Gather blocks until the fetch or network limits is reached
 	var (

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"
@@ -403,6 +404,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()
 
@@ -716,6 +905,11 @@ 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
@@ -731,3 +925,23 @@ 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)
+}