Preprocess contract call with no method sig (#111)

Author: songge-cb

services/construction_service.go

@@ -49,6 +49,8 @@ const (
 	// TokenContractAddressKey is the key in the currency metadata map
 	// that represents the contract address of a token
 	TokenContractAddressKey = "token_address"
+	// NoMethodSig is the method signature name when a contract call does not have one
+	NoMethodSig = "NO-METHOD-SIG"
 )
 
 var (
@@ -958,8 +960,14 @@ func constructERC20VotesDelegateData(to string) []byte {
 func constructContractCallData(methodSig string, methodArgsGeneric interface{}) ([]byte, error) {
 	data := contractCallMethodID(methodSig)
 
+	// preprocess method args for contract call with no method signature
+	args, err := preprocessArgs(methodSig, methodArgsGeneric)
+	if err != nil {
+		return nil, err
+	}
+
 	// switch on the type of the method args. method args can come in from json as either a string or list of strings
-	switch methodArgs := methodArgsGeneric.(type) {
+	switch methodArgs := args.(type) {
 	// case 0: no method arguments, return the selector
 	case nil:
 		return data, nil
@@ -1262,11 +1270,38 @@ func rosettaOperations(
 // contractCallMethodID calculates the first 4 bytes of the method
 // signature for function call on contract
 func contractCallMethodID(methodSig string) []byte {
+	if methodSig == "" || methodSig == NoMethodSig {
+		// contract call without method signature (fallback pattern)
+		return []byte{}
+	}
+
 	fnSignature := []byte(methodSig)
 	hash := crypto.Keccak256(fnSignature)
 	return hash[:4]
 }
 
+// preprocessArgs converts methodArgs to a string value if a contract call has no method signature.
+// In this case, methodArgs contains the pre-compiled ABI data.
+func preprocessArgs(methodSig string, methodArgs interface{}) (interface{}, error) {
+	if methodSig == "" || methodSig == NoMethodSig {
+		switch args := methodArgs.(type) {
+		case []interface{}:
+			if len(args) == 1 {
+				if argStr, ok := args[0].(string); ok {
+					return argStr, nil
+				}
+				return nil, fmt.Errorf("failed to convert method arg \"%T\" to string", args[0])
+			}
+		case []string:
+			if len(args) == 1 {
+				return args[0], nil
+			}
+		}
+	}
+
+	return methodArgs, nil
+}
+
 func bigIntMax(a *big.Int, b *big.Int) *big.Int {
 	if a.Cmp(b) == -1 {
 		return b

services/construction_service_test.go

@@ -18,6 +18,7 @@ import (
 	"context"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math"
 	"math/big"
@@ -1330,6 +1331,26 @@ func TestConstructContractCallData(t *testing.T) {
 			},
 			expectedResult: "cf9d137c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000deaddeaddeaddeaddeaddeaddeaddeaddead0000000000000000000000000000b0935a466e6fa8fda8143c7f4a8c149ca56d06fe",
 		},
+		"nil args": {
+			methodSig:      "deposit()",
+			methodArgs:     nil,
+			expectedResult: "d0e30db0",
+		},
+		"list of non string args": {
+			methodSig:      "register(string,address,bool)",
+			methodArgs:     []interface{}{"bool abc", "0x0000000000000000000000000000000000000000", "true"},
+			expectedResult: "60d7a2780000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000008626f6f6c20616263000000000000000000000000000000000000000000000000",
+		},
+		"method sig is an empty string and args is a list of interface": {
+			methodSig:      "",
+			methodArgs:     []interface{}{"0xabcde12345"},
+			expectedResult: "abcde12345",
+		},
+		"method sig is NO-METHOD-SIG and args is a list of interface": {
+			methodSig:      NoMethodSig,
+			methodArgs:     []interface{}{"0xaabbcc112233"},
+			expectedResult: "aabbcc112233",
+		},
 		"invalid bytes format": {
 			methodSig: "deploy(bytes32,address)",
 			methodArgs: []string{
@@ -1377,3 +1398,63 @@ func TestConstructContractCallData(t *testing.T) {
 		})
 	}
 }
+
+func TestConstruction_preprocessArgs(t *testing.T) {
+	tests := map[string]struct {
+		methodSig  string
+		methodArgs interface{}
+
+		expectedResponse interface{}
+		expectedError    error
+	}{
+		"happy path: method sig is function name": {
+			methodSig: "withdraw(address,uint256,uint32,bytes)",
+			methodArgs: []interface{}{
+				"0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22",
+				"32941055343948244352",
+				"0",
+				"0x"},
+			expectedResponse: []interface{}{
+				"0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22",
+				"32941055343948244352",
+				"0",
+				"0x"},
+		},
+		"happy path: method sig is empty and args is nil": {
+			methodSig:        "",
+			methodArgs:       nil,
+			expectedResponse: nil,
+		},
+		"happy path: method sig is NO-METHOD-SIG and args is a single string": {
+			methodSig:        NoMethodSig,
+			methodArgs:       "0x12345",
+			expectedResponse: "0x12345",
+		},
+		"happy path: method sig is empty and args is a list of interface": {
+			methodSig:        "",
+			methodArgs:       []interface{}{"0xabcde"},
+			expectedResponse: "0xabcde",
+		},
+		"happy path: method sig is NO-METHOD-SIG and args is a list of strings": {
+			methodSig:        NoMethodSig,
+			methodArgs:       []string{"0x1a2b3c"},
+			expectedResponse: "0x1a2b3c",
+		},
+		"unhappy path: args is a list of interface and cannot be converted to strings": {
+			methodSig:     "",
+			methodArgs:    []interface{}{34567},
+			expectedError: errors.New("failed to convert method arg \"int\" to string"),
+		},
+	}
+
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			argsReturned, err := preprocessArgs(test.methodSig, test.methodArgs)
+			if err != nil {
+				assert.EqualError(t, err, test.expectedError.Error())
+			} else {
+				assert.Equal(t, test.expectedResponse, argsReturned)
+			}
+		})
+	}
+}