rpc: marshal getapplicationlog stack as []stackitem.Item

Following neo-project/neo-modules#318

pkg/rpc/client/rpc_test.go

@@ -107,7 +107,7 @@ var rpcClientTestCases = map[string][]rpcClientTestCase{
 			invoke: func(c *Client) (interface{}, error) {
 				return c.GetApplicationLog(util.Uint256{})
 			},
-			serverResponse: `{"id":1,"jsonrpc":"2.0","result":{"txid":"0x17145a039fca704fcdbeb46e6b210af98a1a9e5b9768e46ffc38f71c79ac2521","trigger":"Application","vmstate":"HALT","gasconsumed":"1","stack":[{"type":"Integer","value":1}],"notifications":[]}}`,
+			serverResponse: `{"id":1,"jsonrpc":"2.0","result":{"txid":"0x17145a039fca704fcdbeb46e6b210af98a1a9e5b9768e46ffc38f71c79ac2521","trigger":"Application","vmstate":"HALT","gasconsumed":"1","stack":[{"type":"Integer","value":"1"}],"notifications":[]}}`,
 			result: func(c *Client) interface{} {
 				txHash, err := util.Uint256DecodeStringLE("17145a039fca704fcdbeb46e6b210af98a1a9e5b9768e46ffc38f71c79ac2521")
 				if err != nil {
@@ -118,7 +118,7 @@ var rpcClientTestCases = map[string][]rpcClientTestCase{
 					Trigger:     "Application",
 					VMState:     "HALT",
 					GasConsumed: 1,
-					Stack:       []smartcontract.Parameter{{Type: smartcontract.IntegerType, Value: int64(1)}},
+					Stack:       []stackitem.Item{stackitem.NewBigInteger(big.NewInt(1))},
 					Events:      []result.NotificationEvent{},
 				}
 			},

pkg/rpc/response/result/application_log.go

@@ -1,6 +1,8 @@
 package result
 
 import (
+	"encoding/json"
+
 	"github.com/nspcc-dev/neo-go/pkg/core/state"
 	"github.com/nspcc-dev/neo-go/pkg/smartcontract"
 	"github.com/nspcc-dev/neo-go/pkg/util"
@@ -10,12 +12,12 @@ import (
 // ApplicationLog wrapper used for the representation of the
 // state.AppExecResult based on the specific tx on the RPC Server.
 type ApplicationLog struct {
-	TxHash      util.Uint256              `json:"txid"`
-	Trigger     string                    `json:"trigger"`
-	VMState     string                    `json:"vmstate"`
-	GasConsumed int64                     `json:"gasconsumed,string"`
-	Stack       []smartcontract.Parameter `json:"stack"`
-	Events      []NotificationEvent       `json:"notifications"`
+	TxHash      util.Uint256
+	Trigger     string
+	VMState     string
+	GasConsumed int64
+	Stack       []stackitem.Item
+	Events      []NotificationEvent
 }
 
 //NotificationEvent response wrapper
@@ -25,6 +27,73 @@ type NotificationEvent struct {
 	Item     smartcontract.Parameter `json:"state"`
 }
 
+type applicationLogAux struct {
+	TxHash      util.Uint256        `json:"txid"`
+	Trigger     string              `json:"trigger"`
+	VMState     string              `json:"vmstate"`
+	GasConsumed int64               `json:"gasconsumed,string"`
+	Stack       json.RawMessage     `json:"stack"`
+	Events      []NotificationEvent `json:"notifications"`
+}
+
+// MarshalJSON implements json.Marshaler.
+func (l ApplicationLog) MarshalJSON() ([]byte, error) {
+	var st json.RawMessage
+	arr := make([]json.RawMessage, len(l.Stack))
+	for i := range arr {
+		data, err := stackitem.ToJSONWithTypes(l.Stack[i])
+		if err != nil {
+			st = []byte("error: recursive reference")
+			break
+		}
+		arr[i] = data
+	}
+
+	var err error
+	if st == nil {
+		st, err = json.Marshal(arr)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return json.Marshal(&applicationLogAux{
+		TxHash:      l.TxHash,
+		Trigger:     l.Trigger,
+		VMState:     l.VMState,
+		GasConsumed: l.GasConsumed,
+		Stack:       st,
+		Events:      l.Events,
+	})
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (l *ApplicationLog) UnmarshalJSON(data []byte) error {
+	aux := new(applicationLogAux)
+	if err := json.Unmarshal(data, aux); err != nil {
+		return err
+	}
+	var arr []json.RawMessage
+	if err := json.Unmarshal(aux.Stack, &arr); err == nil {
+		st := make([]stackitem.Item, len(arr))
+		for i := range arr {
+			st[i], err = stackitem.FromJSONWithTypes(arr[i])
+			if err != nil {
+				break
+			}
+		}
+		if err == nil {
+			l.Stack = st
+		}
+	}
+	l.Trigger = aux.Trigger
+	l.TxHash = aux.TxHash
+	l.VMState = aux.VMState
+	l.Events = aux.Events
+	l.GasConsumed = aux.GasConsumed
+
+	return nil
+}
+
 // StateEventToResultNotification converts state.NotificationEvent to
 // result.NotificationEvent.
 func StateEventToResultNotification(event state.NotificationEvent) NotificationEvent {
@@ -43,17 +112,12 @@ func NewApplicationLog(appExecRes *state.AppExecResult) ApplicationLog {
 	for _, e := range appExecRes.Events {
 		events = append(events, StateEventToResultNotification(e))
 	}
-	st := make([]smartcontract.Parameter, len(appExecRes.Stack))
-	seen := make(map[stackitem.Item]bool)
-	for i := range appExecRes.Stack {
-		st[i] = smartcontract.ParameterFromStackItem(appExecRes.Stack[i], seen)
-	}
 	return ApplicationLog{
 		TxHash:      appExecRes.TxHash,
 		Trigger:     appExecRes.Trigger.String(),
 		VMState:     appExecRes.VMState.String(),
 		GasConsumed: appExecRes.GasConsumed,
-		Stack:       st,
+		Stack:       appExecRes.Stack,
 		Events:      events,
 	}
 }