batching: Add more unit tests.

op-service/sources/batching/call.go

@@ -66,6 +66,26 @@ func (c *ContractCall) Unpack(hex hexutil.Bytes) (*CallResult, error) {
 	return &CallResult{out: out}, nil
 }
 
+func toCallArg(msg ethereum.CallMsg) interface{} {
+	arg := map[string]interface{}{
+		"from": msg.From,
+		"to":   msg.To,
+	}
+	if len(msg.Data) > 0 {
+		arg["data"] = hexutil.Bytes(msg.Data)
+	}
+	if msg.Value != nil {
+		arg["value"] = (*hexutil.Big)(msg.Value)
+	}
+	if msg.Gas != 0 {
+		arg["gas"] = hexutil.Uint64(msg.Gas)
+	}
+	if msg.GasPrice != nil {
+		arg["gasPrice"] = (*hexutil.Big)(msg.GasPrice)
+	}
+	return arg
+}
+
 type CallResult struct {
 	out []interface{}
 }

op-service/sources/batching/call_test.go

+package batching
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/stretchr/testify/require"
+)
+
+func TestContractCall_ToCallArgs(t *testing.T) {
+	addr := common.Address{0xbd}
+	testAbi, err := bindings.ERC20MetaData.GetAbi()
+	require.NoError(t, err)
+	call := NewContractCall(testAbi, addr, "approve", common.Address{0xcc}, big.NewInt(1234444))
+	args, err := call.ToCallArgs()
+	require.NoError(t, err)
+	argMap, ok := args.(map[string]interface{})
+	require.True(t, ok)
+	require.Equal(t, argMap["from"], common.Address{})
+	require.Equal(t, argMap["to"], &addr)
+	expectedData, err := call.Pack()
+	require.NoError(t, err)
+	require.Equal(t, argMap["data"], hexutil.Bytes(expectedData))
+
+	require.NotContains(t, argMap, "value")
+	require.NotContains(t, argMap, "gas")
+	require.NotContains(t, argMap, "gasPrice")
+}
+
+func TestContractCall_Pack(t *testing.T) {
+	addr := common.Address{0xbd}
+	testAbi, err := bindings.ERC20MetaData.GetAbi()
+	require.NoError(t, err)
+	sender := common.Address{0xcc}
+	amount := big.NewInt(1234444)
+	call := NewContractCall(testAbi, addr, "approve", sender, amount)
+	actual, err := call.Pack()
+	require.NoError(t, err)
+
+	expected, err := testAbi.Pack("approve", sender, amount)
+	require.NoError(t, err)
+	require.Equal(t, actual, expected)
+}
+
+func TestContractCall_PackInvalid(t *testing.T) {
+	addr := common.Address{0xbd}
+	testAbi, err := bindings.ERC20MetaData.GetAbi()
+	require.NoError(t, err)
+	// Second arg should be a *big.Int so packing should fail
+	call := NewContractCall(testAbi, addr, "approve", common.Address{0xcc}, uint32(123))
+	_, err = call.Pack()
+	require.Error(t, err)
+}
+
+func TestContractCall_Unpack(t *testing.T) {
+	addr := common.Address{0xbd}
+	testAbi, err := bindings.ERC20MetaData.GetAbi()
+	require.NoError(t, err)
+	call := NewContractCall(testAbi, addr, "balanceOf", common.Address{0xcc})
+	outputs := testAbi.Methods["balanceOf"].Outputs
+	expected := big.NewInt(1234)
+	packed, err := outputs.Pack(expected)
+	require.NoError(t, err)
+
+	unpacked, err := call.Unpack(packed)
+	require.NoError(t, err)
+	require.Equal(t, unpacked.GetBigInt(0), expected)
+}
+
+func TestContractCall_UnpackInvalid(t *testing.T) {
+	addr := common.Address{0xbd}
+	testAbi, err := bindings.ERC20MetaData.GetAbi()
+	require.NoError(t, err)
+	call := NewContractCall(testAbi, addr, "balanceOf", common.Address{0xcc})
+
+	// Input data is the wrong format and won't unpack successfully
+	inputPacked, err := call.Pack()
+	require.NoError(t, err)
+
+	_, err = call.Unpack(inputPacked)
+	require.Error(t, err)
+}
+
+func TestCallResult_GetValues(t *testing.T) {
+	tests := []struct {
+		name     string
+		getter   func(result *CallResult, i int) interface{}
+		expected interface{}
+	}{
+		{
+			name: "GetUint8",
+			getter: func(result *CallResult, i int) interface{} {
+				return result.GetUint8(i)
+			},
+			expected: uint8(12),
+		},
+		{
+			name: "GetUint32",
+			getter: func(result *CallResult, i int) interface{} {
+				return result.GetUint32(i)
+			},
+			expected: uint32(12346),
+		},
+		{
+			name: "GetUint64",
+			getter: func(result *CallResult, i int) interface{} {
+				return result.GetUint64(i)
+			},
+			expected: uint64(12346),
+		},
+		{
+			name: "GetBool",
+			getter: func(result *CallResult, i int) interface{} {
+				return result.GetBool(i)
+			},
+			expected: true,
+		},
+		{
+			name: "GetHash",
+			getter: func(result *CallResult, i int) interface{} {
+				return result.GetHash(i)
+			},
+			expected: ([32]byte)(common.Hash{0xaa, 0xbb, 0xcc}),
+		},
+		{
+			name: "GetBigInt",
+			getter: func(result *CallResult, i int) interface{} {
+				return result.GetBigInt(i)
+			},
+			expected: big.NewInt(2398423),
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			callResult := &CallResult{[]interface{}{nil, 0, "abc", test.expected, "xyz", 3, nil}}
+			actual := test.getter(callResult, 3)
+			require.EqualValues(t, test.expected, actual)
+		})
+	}
+}

op-service/sources/batching/multicall.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/rpc"
 )
@@ -80,23 +79,3 @@ func (m *MultiCaller) CallLatest(ctx context.Context, calls ...*ContractCall) ([
 	}
 	return callResults, nil
 }
-
-func toCallArg(msg ethereum.CallMsg) interface{} {
-	arg := map[string]interface{}{
-		"from": msg.From,
-		"to":   msg.To,
-	}
-	if len(msg.Data) > 0 {
-		arg["data"] = hexutil.Bytes(msg.Data)
-	}
-	if msg.Value != nil {
-		arg["value"] = (*hexutil.Big)(msg.Value)
-	}
-	if msg.Gas != 0 {
-		arg["gas"] = hexutil.Uint64(msg.Gas)
-	}
-	if msg.GasPrice != nil {
-		arg["gasPrice"] = (*hexutil.Big)(msg.GasPrice)
-	}
-	return arg
-}