From 55ed0ff07c6cf2dc8b422a3bf8d623a039ad6dbd Mon Sep 17 00:00:00 2001
From: Taylor Gerring <taylor.gerring@gmail.com>
Date: Tue, 3 Feb 2015 17:29:29 -0600
Subject: [PATCH] Update RPC message format

---
 rpc/http/server.go | 11 +++++++----
 rpc/message.go     | 37 ++++++++++++++++++-------------------
 rpc/ws/server.go   | 13 ++++++++-----
 3 files changed, 33 insertions(+), 28 deletions(-)

diff --git a/rpc/http/server.go b/rpc/http/server.go
index 965727a4ed..caa50d67ca 100644
--- a/rpc/http/server.go
+++ b/rpc/http/server.go
@@ -84,6 +84,7 @@ func (s *RpcHttpServer) Start() {
 }
 
 func (s *RpcHttpServer) apiHandler(api *rpc.EthereumApi) http.Handler {
+	var jsonrpcver string = "2.0"
 	fn := func(w http.ResponseWriter, req *http.Request) {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 
@@ -91,20 +92,22 @@ func (s *RpcHttpServer) apiHandler(api *rpc.EthereumApi) http.Handler {
 
 		reqParsed, reqerr := JSON.ParseRequestBody(req)
 		if reqerr != nil {
-			JSON.Send(w, &rpc.RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: rpc.ErrorParseRequest})
+			jsonerr := &rpc.RpcErrorObject{-32700, rpc.ErrorParseRequest}
+			JSON.Send(w, &rpc.RpcErrorResponse{JsonRpc: jsonrpcver, ID: nil, Error: jsonerr})
 			return
 		}
 
 		var response interface{}
 		reserr := api.GetRequestReply(&reqParsed, &response)
 		if reserr != nil {
-			rpchttplogger.Errorln(reserr)
-			JSON.Send(w, &rpc.RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: reserr.Error()})
+			rpchttplogger.Warnln(reserr)
+			jsonerr := &rpc.RpcErrorObject{-32603, reserr.Error()}
+			JSON.Send(w, &rpc.RpcErrorResponse{JsonRpc: jsonrpcver, ID: &reqParsed.ID, Error: jsonerr})
 			return
 		}
 
 		rpchttplogger.Debugf("Generated response: %T %s", response, response)
-		JSON.Send(w, &rpc.RpcSuccessResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: false, Result: response})
+		JSON.Send(w, &rpc.RpcSuccessResponse{JsonRpc: jsonrpcver, ID: reqParsed.ID, Result: response})
 	}
 
 	return http.HandlerFunc(fn)
diff --git a/rpc/message.go b/rpc/message.go
index 26fac9d377..054b7a5789 100644
--- a/rpc/message.go
+++ b/rpc/message.go
@@ -33,25 +33,6 @@ const (
 	ErrorDecodeArgs     = "Error: Could not decode arguments"
 )
 
-type ErrorResponse struct {
-	Error     bool   `json:"error"`
-	ErrorText string `json:"errorText"`
-}
-
-type RpcSuccessResponse struct {
-	ID      int         `json:"id"`
-	JsonRpc string      `json:"jsonrpc"`
-	Error   bool        `json:"error"`
-	Result  interface{} `json:"result"`
-}
-
-type RpcErrorResponse struct {
-	ID        int    `json:"id"`
-	JsonRpc   string `json:"jsonrpc"`
-	Error     bool   `json:"error"`
-	ErrorText string `json:"errortext"`
-}
-
 type RpcRequest struct {
 	JsonRpc string            `json:"jsonrpc"`
 	ID      int               `json:"id"`
@@ -59,6 +40,24 @@ type RpcRequest struct {
 	Params  []json.RawMessage `json:"params"`
 }
 
+type RpcSuccessResponse struct {
+	ID      int         `json:"id"`
+	JsonRpc string      `json:"jsonrpc"`
+	Result  interface{} `json:"result"`
+}
+
+type RpcErrorResponse struct {
+	ID      *int            `json:"id"`
+	JsonRpc string          `json:"jsonrpc"`
+	Error   *RpcErrorObject `json:"error"`
+}
+
+type RpcErrorObject struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	// Data    interface{} `json:"data"`
+}
+
 func NewErrorResponse(msg string) error {
 	return errors.New(msg)
 }
diff --git a/rpc/ws/server.go b/rpc/ws/server.go
index 85cacf80bb..6be4e8ce93 100644
--- a/rpc/ws/server.go
+++ b/rpc/ws/server.go
@@ -28,6 +28,7 @@ import (
 )
 
 var wslogger = logger.NewLogger("RPC-WS")
+var JSON rpc.JsonWrapper
 
 type WebSocketServer struct {
 	pipe     *xeth.XEth
@@ -90,27 +91,29 @@ func (s *WebSocketServer) apiHandler(api *rpc.EthereumApi) http.Handler {
 }
 
 func sockHandler(api *rpc.EthereumApi) websocket.Handler {
+	var jsonrpcver string = "2.0"
 	fn := func(conn *websocket.Conn) {
 		for {
 			wslogger.Debugln("Handling request")
 			var reqParsed rpc.RpcRequest
 
 			if err := websocket.JSON.Receive(conn, &reqParsed); err != nil {
-				wslogger.Debugln(rpc.ErrorParseRequest)
-				websocket.JSON.Send(conn, rpc.RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: rpc.ErrorParseRequest})
+				jsonerr := &rpc.RpcErrorObject{-32700, rpc.ErrorParseRequest}
+				JSON.Send(conn, &rpc.RpcErrorResponse{JsonRpc: jsonrpcver, ID: nil, Error: jsonerr})
 				continue
 			}
 
 			var response interface{}
 			reserr := api.GetRequestReply(&reqParsed, &response)
 			if reserr != nil {
-				wslogger.Errorln(reserr)
-				websocket.JSON.Send(conn, rpc.RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: reserr.Error()})
+				wslogger.Warnln(reserr)
+				jsonerr := &rpc.RpcErrorObject{-32603, reserr.Error()}
+				JSON.Send(conn, &rpc.RpcErrorResponse{JsonRpc: jsonrpcver, ID: &reqParsed.ID, Error: jsonerr})
 				continue
 			}
 
 			wslogger.Debugf("Generated response: %T %s", response, response)
-			websocket.JSON.Send(conn, rpc.RpcSuccessResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: false, Result: response})
+			JSON.Send(conn, &rpc.RpcSuccessResponse{JsonRpc: jsonrpcver, ID: reqParsed.ID, Result: response})
 		}
 	}
 	return websocket.Handler(fn)