Return Revert result as Data

jsonrpc/codec.go

@@ -93,6 +93,26 @@ func (e *ObjectError) Error() string {
 	return string(data)
 }
 
+func (e *ObjectError) MarshalJSON() ([]byte, error) {
+	var ds string
+
+	if data, ok := e.Data.([]byte); ok {
+		if len(data) > 0 {
+			ds = "0x" + string(data)
+		}
+	}
+
+	return json.Marshal(&struct {
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+		Data    string `json:"data,omitempty"`
+	}{
+		Code:    e.Code,
+		Message: e.Message,
+		Data:    ds,
+	})
+}
+
 const (
 	pending  = "pending"
 	latest   = "latest"
@@ -190,8 +210,8 @@ func (b *BlockNumber) UnmarshalJSON(buffer []byte) error {
 }
 
 // NewRPCErrorResponse is used to create a custom error response
-func NewRPCErrorResponse(id interface{}, errCode int, err string, jsonrpcver string) Response {
-	errObject := &ObjectError{errCode, err, nil}
+func NewRPCErrorResponse(id interface{}, errCode int, err string, data []byte, jsonrpcver string) Response {
+	errObject := &ObjectError{errCode, err, data}
 
 	response := &ErrorResponse{
 		JSONRPC: jsonrpcver,
@@ -209,7 +229,7 @@ func NewRPCResponse(id interface{}, jsonrpcver string, reply []byte, err Error)
 	case nil:
 		response = &SuccessResponse{JSONRPC: jsonrpcver, ID: id, Result: reply}
 	default:
-		response = NewRPCErrorResponse(id, err.ErrorCode(), err.Error(), jsonrpcver)
+		response = NewRPCErrorResponse(id, err.ErrorCode(), err.Error(), reply, jsonrpcver)
 	}
 
 	return response

jsonrpc/dispatcher.go

@@ -328,7 +328,7 @@ func (d *Dispatcher) Handle(reqBody []byte) ([]byte, error) {
 	for _, req := range requests {
 		var response, err = d.handleReq(req)
 		if err != nil {
-			errorResponse := NewRPCResponse(req.ID, "2.0", nil, err)
+			errorResponse := NewRPCResponse(req.ID, "2.0", response, err)
 			responses = append(responses, errorResponse)
 
 			continue
@@ -371,17 +371,26 @@ func (d *Dispatcher) handleReq(req Request) ([]byte, Error) {
 		}
 	}
 
+	var (
+		data []byte
+		err  error
+		ok   bool
+	)
+
 	output := fd.fv.Call(inArgs)
 	if err := getError(output[1]); err != nil {
 		d.logInternalError(req.Method, err)
 
-		return nil, NewInvalidRequestError(err.Error())
-	}
+		if res := output[0].Interface(); res != nil {
+			data, ok = res.([]byte)
 
-	var (
-		data []byte
-		err  error
-	)
+			if !ok {
+				return nil, NewInternalError(err.Error())
+			}
+		}
+
+		return data, NewInvalidRequestError(err.Error())
+	}
 
 	if res := output[0].Interface(); res != nil {
 		data, err = json.Marshal(res)

jsonrpc/eth_blockchain_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/0xPolygon/polygon-edge/blockchain"
+	"github.com/0xPolygon/polygon-edge/helper/hex"
 	"github.com/0xPolygon/polygon-edge/helper/progress"
 	"github.com/0xPolygon/polygon-edge/state/runtime"
 	"github.com/0xPolygon/polygon-edge/types"
@@ -333,6 +334,33 @@ func TestEth_Call(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NotNil(t, res)
 	})
+
+	t.Run("returns error and result as data of a reverted transaction execution", func(t *testing.T) {
+		t.Parallel()
+
+		returnValue := []byte("Reverted()")
+
+		store := newMockBlockStore()
+		store.add(newTestBlock(100, hash1))
+		store.ethCallError = runtime.ErrExecutionReverted
+		store.returnValue = returnValue
+		eth := newTestEthEndpoint(store)
+		contractCall := &txnArgs{
+			From:     &addr0,
+			To:       &addr1,
+			Gas:      argUintPtr(100000),
+			GasPrice: argBytesPtr([]byte{0x64}),
+			Value:    argBytesPtr([]byte{0x64}),
+			Data:     nil,
+			Nonce:    argUintPtr(0),
+		}
+
+		res, err := eth.Call(contractCall, BlockNumberOrHash{}, nil)
+		assert.Error(t, err)
+		assert.NotNil(t, res)
+		bres := res.([]byte) //nolint:forcetypeassert
+		assert.Equal(t, []byte(hex.EncodeToString(returnValue)), bres)
+	})
 }
 
 type testStore interface {
@@ -348,6 +376,7 @@ type mockBlockStore struct {
 	isSyncing       bool
 	averageGasPrice int64
 	ethCallError    error
+	returnValue     []byte
 }
 
 func newMockBlockStore() *mockBlockStore {
@@ -518,7 +547,10 @@ func (m *mockBlockStore) GetAvgGasPrice() *big.Int {
 }
 
 func (m *mockBlockStore) ApplyTxn(header *types.Header, txn *types.Transaction, overrides types.StateOverride) (*runtime.ExecutionResult, error) {
-	return &runtime.ExecutionResult{Err: m.ethCallError}, nil
+	return &runtime.ExecutionResult{
+		Err:         m.ethCallError,
+		ReturnValue: m.returnValue,
+	}, nil
 }
 
 func (m *mockBlockStore) SubscribeEvents() blockchain.Subscription {

jsonrpc/eth_endpoint.go

@@ -1,6 +1,7 @@
 package jsonrpc
 
 import (
+	"encoding/hex"
 	"errors"
 	"fmt"
 	"math/big"
@@ -488,7 +489,7 @@ func (e *Eth) Call(arg *txnArgs, filter BlockNumberOrHash, apiOverride *stateOve
 
 	// Check if an EVM revert happened
 	if result.Reverted() {
-		return nil, constructErrorFromRevert(result)
+		return []byte(hex.EncodeToString(result.ReturnValue)), constructErrorFromRevert(result)
 	}
 
 	if result.Failed() {