feat: proposal decoding interfaces + EVM implementation (#301)

This pull request introduces a new interface for decoding operations and
implements it for the EVM decoder. The most important changes include
the creation of a `DecodedOperation` interface, updates to the `Decoder`
interface, and the implementation of these interfaces in the EVM
decoder.

### Interface and Type Definitions:

* Added `DecodedOperation` interface with methods `MethodName`, `Args`,
and `String` in `sdk/decoder.go`.
* Updated `Decoder` interface to use `DecodedOperation` as the return
type of the `Decode` method in `sdk/decoder.go`.

### EVM Decoder Implementation:

* Implemented `DecodedOperation` struct with methods `MethodName`,
`Args`, and `String` in `sdk/evm/decoder.go`.
* Implemented `Decoder` struct with the `Decode` method in
`sdk/evm/decoder.go`.
* Added `ParseFunctionCall` function to parse the ABI and transaction
data into a `DecodedOperation` in `sdk/evm/decoder.go`.

---------

Co-authored-by: Graham Goh <[email protected]>

Author: akhilchainani

.changeset/moody-llamas-serve.md

@@ -0,0 +1,5 @@
+---
+"@smartcontractkit/mcms": minor
+---
+
+Expose additional functions to help with proposal decoding

sdk/decoded_operation.go

@@ -0,0 +1,14 @@
+package sdk
+
+type DecodedOperation interface {
+	MethodName() string // MethodName returns the name of the method.
+	Keys() []string     // Keys returns the names of the input arguments.
+	Args() []any        // Args returns the values input arguments.
+
+	// String returns a human readable representation of the decoded operation.
+	//
+	// The first return value is the method name.
+	// The second return value is a string representation of the input arguments.
+	// The third return value is an error if there was an issue generating the string.
+	String() (string, string, error)
+}

sdk/decoder.go

@@ -8,5 +8,9 @@ import (
 //
 // This is only required if the chain supports decoding.
 type Decoder interface {
-	Decode(op types.Operation, abi string) (methodName string, args string, err error)
+	// Decode decodes the transaction data of a chain operation.
+	//
+	// contractInterfaces is the collection of functions and contract interfaces of the contract
+	// that the operation is interacting with.
+	Decode(op types.Transaction, contractInterfaces string) (DecodedOperation, error)
 }

sdk/evm/decoded_operation.go

@@ -0,0 +1,57 @@
+package evm
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/smartcontractkit/mcms/sdk"
+)
+
+type DecodedOperation struct {
+	FunctionName string
+	InputArgs    []any
+	InputKeys    []string
+}
+
+var _ sdk.DecodedOperation = &DecodedOperation{}
+
+func NewDecodedOperation(functionName string, inputKeys []string, inputArgs []any) (*DecodedOperation, error) {
+	if len(inputKeys) != len(inputArgs) {
+		return nil, fmt.Errorf("input keys and input args must have the same length")
+	}
+
+	return &DecodedOperation{
+		FunctionName: functionName,
+		InputKeys:    inputKeys,
+		InputArgs:    inputArgs,
+	}, nil
+}
+
+func (d *DecodedOperation) MethodName() string {
+	return d.FunctionName
+}
+
+func (d *DecodedOperation) Keys() []string {
+	return d.InputKeys
+}
+
+func (d *DecodedOperation) Args() []any {
+	return d.InputArgs
+}
+
+func (d *DecodedOperation) String() (string, string, error) {
+	// Create a human readable representation of the decoded operation
+	// by displaying a map of input keys to input values
+	// e.g. {"key1": "value1", "key2": "value2"}
+	inputMap := make(map[string]any)
+	for i, key := range d.InputKeys {
+		inputMap[key] = d.InputArgs[i]
+	}
+
+	byteMap, err := json.MarshalIndent(inputMap, "", "  ")
+	if err != nil {
+		return "", "", err
+	}
+
+	return d.FunctionName, string(byteMap), nil
+}

sdk/evm/decoded_operation_test.go

@@ -0,0 +1,71 @@
+package evm
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewDecodedOperation(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name         string
+		functionName string
+		inputKeys    []string
+		inputArgs    []any
+		wantErr      string
+	}{
+		{
+			name:         "success",
+			functionName: "functionName",
+			inputKeys:    []string{"inputKey1", "inputKey2"},
+			inputArgs:    []any{"inputArg1", "inputArg2"},
+		},
+		{
+			name:         "success with empty input keys and args",
+			functionName: "functionName",
+			inputKeys:    []string{},
+			inputArgs:    []any{},
+		},
+		{
+			name:         "error with mismatched input keys and args",
+			functionName: "functionName",
+			inputKeys:    []string{"inputKey1", "inputKey2"},
+			inputArgs:    []any{"inputArg1"},
+			wantErr:      "input keys and input args must have the same length",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := NewDecodedOperation(tt.functionName, tt.inputKeys, tt.inputArgs)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.EqualError(t, err, tt.wantErr)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.functionName, got.FunctionName)
+				assert.Equal(t, tt.inputKeys, got.InputKeys)
+				assert.Equal(t, tt.inputArgs, got.InputArgs)
+
+				// Test member functions
+				assert.Equal(t, tt.functionName, got.MethodName())
+				assert.Equal(t, tt.inputKeys, got.Keys())
+				assert.Equal(t, tt.inputArgs, got.Args())
+
+				// Test String()
+				fn, inputs, err := got.String()
+				require.NoError(t, err)
+				assert.Equal(t, tt.functionName, fn)
+				for i := range tt.inputKeys {
+					assert.Contains(t, inputs, fmt.Sprintf(`"%s": "%v"`, tt.inputKeys[i], tt.inputArgs[i]))
+				}
+			}
+		})
+	}
+}

sdk/evm/decoder.go

@@ -0,0 +1,56 @@
+package evm
+
+import (
+	"strings"
+
+	geth_abi "github.com/ethereum/go-ethereum/accounts/abi"
+
+	"github.com/smartcontractkit/mcms/sdk"
+	"github.com/smartcontractkit/mcms/types"
+)
+
+type Decoder struct{}
+
+var _ sdk.Decoder = &Decoder{}
+
+func NewDecoder() *Decoder {
+	return &Decoder{}
+}
+
+func (d *Decoder) Decode(tx types.Transaction, contractInterfaces string) (sdk.DecodedOperation, error) {
+	return ParseFunctionCall(contractInterfaces, tx.Data)
+}
+
+// ParseFunctionCall parses a full data payload (with function selector at the front of it) and a full contract ABI
+// into a function name and an array of inputs.
+func ParseFunctionCall(fullAbi string, data []byte) (*DecodedOperation, error) {
+	// Parse the ABI
+	parsedAbi, err := geth_abi.JSON(strings.NewReader(fullAbi))
+	if err != nil {
+		return &DecodedOperation{}, err
+	}
+
+	// Extract the method from the data
+	method, err := parsedAbi.MethodById(data[:4])
+	if err != nil {
+		return &DecodedOperation{}, err
+	}
+
+	// Unpack the data
+	inputs, err := method.Inputs.UnpackValues(data[4:])
+	if err != nil {
+		return &DecodedOperation{}, err
+	}
+
+	// Get the keys of the inputs
+	methodKeys := make([]string, len(method.Inputs))
+	for i, input := range method.Inputs {
+		methodKeys[i] = input.Name
+	}
+
+	return &DecodedOperation{
+		FunctionName: method.Name,
+		InputKeys:    methodKeys,
+		InputArgs:    inputs,
+	}, nil
+}

sdk/evm/decoder_test.go

@@ -0,0 +1,72 @@
+package evm
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/smartcontractkit/mcms/sdk/evm/bindings"
+	"github.com/smartcontractkit/mcms/types"
+)
+
+func TestDecoder(t *testing.T) {
+	t.Parallel()
+
+	// Get ABI
+	timelockAbi, err := bindings.RBACTimelockMetaData.GetAbi()
+	require.NoError(t, err)
+	exampleRole := crypto.Keccak256Hash([]byte("EXAMPLE_ROLE"))
+
+	// Grant role data
+	grantRoleData, err := timelockAbi.Pack("grantRole", [32]byte(exampleRole), common.HexToAddress("0x123"))
+	require.NoError(t, err)
+
+	tests := []struct {
+		name               string
+		give               types.Operation
+		contractInterfaces string
+		want               *DecodedOperation
+		wantErr            string
+	}{
+		{
+			name: "success",
+			give: types.Operation{
+				ChainSelector: 1,
+				Transaction: NewTransaction(
+					common.HexToAddress("0xTestTarget"),
+					grantRoleData,
+					big.NewInt(0),
+					"RBACTimelock",
+					[]string{"grantRole"},
+				),
+			},
+			contractInterfaces: bindings.RBACTimelockABI,
+			want: &DecodedOperation{
+				FunctionName: "grantRole",
+				InputKeys:    []string{"role", "account"},
+				InputArgs:    []any{[32]byte(exampleRole.Bytes()), common.HexToAddress("0x0000000000000000000000000000000000000123")},
+			},
+			wantErr: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			d := NewDecoder()
+			got, err := d.Decode(tt.give.Transaction, tt.contractInterfaces)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.EqualError(t, err, tt.wantErr)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.want, got)
+			}
+		})
+	}
+}