Merge pull request #14 from decentrio/netflix/jsonrpc

jsonrpc fixes

Author: netflix-and-chilll

README.md

@@ -28,7 +28,7 @@ upstream:
 # If a port is set to 0, the service of that port won't start.
 port:
     rpc: 26657
-    api: 1317
+    api: 0 # Disable API service
     grpc: 9090
     jsonrpc: 8545
     jsonrpc_ws: 8546
@@ -115,3 +115,16 @@ grpcurl -d '{"height": "123"}' \
 grpcurl -plaintext -d '{"hash": "64DFDC0F4B9096ADFC644B2DF087E7B9225C8601719C4C2BB2E979AD83081713"}' \
     localhost:5002 cosmos.tx.v1beta1.Service/GetTx
 ```
+
+### JSON RPC
+```bash
+curl -X POST "http://localhost:5005" -d '{                                    
+        "jsonrpc":"2.0",
+        "method":"eth_getBlockByHash",
+        "params":[
+                "0x68f04262ea363216fae99a7498502075c6aacc42bdc4db7c29e7f64c2fab0fda", 
+                true
+        ],
+        "id":1
+}' -H "Content-Type: application/json"
+```

config.yaml.example

@@ -1,37 +1,46 @@
 package gateway
 
 import (
-	"context"
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"log"
+	"math"
 	"net/http"
 	"os"
 	"os/signal"
+	"strconv"
+	"strings"
 	"sync/atomic"
 	"syscall"
 	"time"
 
-	// "github.com/cometbft/cometbft/rpc/jsonrpc/types"
 	"github.com/decentrio/gateway/config"
+	"github.com/decentrio/gateway/utils"
 )
 
+// Error type
+type JSONRPCError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
 // JSON-RPC request format
 type JSONRPCRequest struct {
-	JSONRPC string      `json:"jsonrpc"`
-	Method  string      `json:"method"`
-	Params  interface{} `json:"params"`
-	ID      int         `json:"id"`
+	JSONRPC string      	`json:"jsonrpc"`
+	ID      int         	`json:"id"`
+	Method  string      	`json:"method"`
+	Params  json.RawMessage `json:"params"`
 }
 
 // JSON-RPC response format
 type JSONRPCResponse struct {
 	JSONRPC string      `json:"jsonrpc"`
-	Result  interface{} `json:"result"`
-	Error   interface{} `json:"error,omitempty"`
 	ID      int         `json:"id"`
+	Result  any 		`json:"result,omitempty"`
+	Error   *JSONRPCError `json:"error,omitempty"`
 }
 
 var (
@@ -117,74 +126,213 @@ func trackRequestsMiddleware(next http.HandlerFunc) http.HandlerFunc {
 }
 
 func handleJSONRPC(w http.ResponseWriter, r *http.Request) {
-	var node *config.Node
+	var req JSONRPCRequest
+	var res JSONRPCResponse
 	if r.Method != http.MethodPost {
-		http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
+		res = JSONRPCResponse{
+			JSONRPC: "2.0",
+			Error:   &JSONRPCError{Code: -32600, Message: "Invalid request"},
+			ID:      1,
+		}
+		json.NewEncoder(w).Encode(res)
 		return
 	}
 
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
-		http.Error(w, "Failed to read request body", http.StatusInternalServerError)
+		res = JSONRPCResponse{
+			JSONRPC: "2.0",
+			Error:   &JSONRPCError{Code: -32600, Message: "Parse error. Invalid JSON: " + err.Error()},
+			ID:      1,
+		}
+		json.NewEncoder(w).Encode(res)
 		return
 	}
-	r.Body.Close()
+	r.Body = io.NopCloser(bytes.NewReader(body))
+	r.Header.Set("Content-Type", "application/json")
+    r.ContentLength = int64(len(body))
 
-	var req JSONRPCRequest
 	err = json.Unmarshal(body, &req)
 	if err != nil {
-		http.Error(w, "Invalid JSON-RPC request", http.StatusBadRequest)
+		res = JSONRPCResponse{
+			JSONRPC: "2.0",
+			Error:   &JSONRPCError{Code: -32600, Message: "Invalid JSON-RPC request: " + err.Error()},
+			ID:      -32700,
+		}
+		json.NewEncoder(w).Encode(res)
 		return
 	}
 
-	fmt.Printf("Received JSON-RPC request: Method=%s, Params=%v, ID=%d\n", req.Method, req.Params, req.ID)
+	fmt.Printf("Received JSON-RPC request: Method=%s, Params=%v\n", req.Method, req.Params)	
+	paramsMap := make([]any, len(req.Params))
+	json.Unmarshal(req.Params, &paramsMap)
+	var height uint64 = math.MaxUint64
+
+	switch req.Method {
+		case "eth_getTransactionByHash", // tx hash in params
+			 "eth_getTransactionReceipt",
+			 "eth_getBlockByHash", // block hash in params
+			 "eth_getBlockTransactionCountByHash",
+			 "eth_getTransactionByBlockHashAndIndex",
+			 "eth_getUncleByBlockHashAndIndex":
+			checkRequestManually(w, r)
+			return
+		case "eth_newFilter",  /// ????
+			 "eth_getLogs":
+			res = JSONRPCResponse{
+				JSONRPC: "2.0",
+				Error:   &JSONRPCError{Code: -32600, Message: "Method not supported yet"},
+				ID:      1,
+			}
+			json.NewEncoder(w).Encode(res)
+			return
+		case "eth_getBalance",// param 1
+			"eth_getTransactionCount",
+			"eth_getCode",
+			"eth_call":
+			height, err = getHeightFromParams(paramsMap, 1)
+			if err != nil {
+				res = JSONRPCResponse{
+					JSONRPC: "2.0",
+					Error:   &JSONRPCError{Code: -32600, Message: err.Error()},
+					ID:      1,
+				}
+				json.NewEncoder(w).Encode(res)
+				return
+			}
+		case "eth_getStorageAt": // param 2
+			height, err = getHeightFromParams(paramsMap, 2)
+			if err != nil {
+				res = JSONRPCResponse{
+					JSONRPC: "2.0",
+					Error:   &JSONRPCError{Code: -32600, Message: err.Error()},
+					ID:      1,
+				}
+				json.NewEncoder(w).Encode(res)
+				return
+			}
+		case "eth_getBlockTransactionCountByNumber", // param 0
+			"eth_getBlockByNumber", 
+			"eth_getTransactionByBlockNumberAndIndex",
+			"eth_getUncleByBlockNumberAndIndex": 
+			height, err = getHeightFromParams(paramsMap, 0)
+			if err != nil {
+				res = JSONRPCResponse{
+					JSONRPC: "2.0",
+					Error:   &JSONRPCError{Code: -32600, Message: err.Error()},
+					ID:      1,
+				}
+				json.NewEncoder(w).Encode(res)
+				return
+			}
+		default:
+			height = 0
+	}
 
-	var height uint64
-	if params, ok := req.Params.(map[string]interface{}); ok {
-		if h, ok := params["height"].(float64); ok {
-			height = uint64(h)
+	fmt.Printf("Height: %d\n", height)
+	node := config.GetNodebyHeight(height)
+	if node == nil {
+		res = JSONRPCResponse{
+			JSONRPC: "2.0",
+			Error:   &JSONRPCError{Code: -32602, Message: "No nodes found"},
+			ID:      1,
 		}
+
+		json.NewEncoder(w).Encode(res)
+		return
 	}
+	fmt.Println("Node called:", node.JSONRPC)
+	httpUtils.FowardRequest(w, r, node.JSONRPC)
+}
 
 
-	if height > 0 {
-		node = config.GetNodebyHeight(height)
-		if node == nil {
-			http.Error(w, "Node not found", http.StatusNotFound)
-			return
+func getHeightFromParams(params []any, index int) (uint64, error) {
+	if len(params) > index {
+		height, found := params[index].(string)
+		if found {
+			if height == "latest" || height == "pending" {
+				return 0, nil
+			} else if height == "earliest" {
+				return 1, nil // temporary, should be earliest possible
+			} else if strings.HasPrefix(height, "0x") {
+				height = strings.TrimPrefix(height, "0x")
+				if h, err := strconv.ParseUint(height, 16, 64); err == nil {
+					return h, nil
+				} else {
+					return math.MaxUint64, fmt.Errorf("invalid height parameter: %w", err)
+				}
+			} else {
+				return math.MaxUint64, fmt.Errorf("invalid height parameter")
+			}
+		} else {
+			return math.MaxUint64, fmt.Errorf("height not found")
 		}
+	} else {
+		return math.MaxUint64, fmt.Errorf("invalid params")
 	}
+}
 
-	if node != nil {
-		fmt.Printf("Forwarding to Node:", node.JSONRPC)
 
-		reqForward, err := http.NewRequest("POST", node.JSONRPC, bytes.NewReader(body))
-		if err != nil {
-			http.Error(w, "Failed to create request", http.StatusInternalServerError)
-			return
-		}
+func checkRequestManually(w http.ResponseWriter, r *http.Request) {
+	ETH_nodes := config.GetNodesByType("jsonrpc")
+	var msg JSONRPCResponse
 
-		reqForward.Header.Set("Content-Type", "application/json")
+	bodyBytes, err := io.ReadAll(r.Body)
+	if err != nil {
+		msg = JSONRPCResponse{
+			JSONRPC: "2.0",
+			Error:   &JSONRPCError{Code: -32600, Message: "Parse error. Invalid JSON: " + err.Error()},
+			ID:      1,
+		}
+		json.NewEncoder(w).Encode(msg)
+		return
+	}
 
-		client := &http.Client{}
-		resp, err := client.Do(reqForward)
+	for _, url := range ETH_nodes {
+		new_r := r.Clone(r.Context())
+		new_r.Body = io.NopCloser(bytes.NewReader(bodyBytes))
+		res, err := httpUtils.CheckRequest(new_r, url)
 		if err != nil {
-			http.Error(w, "Failed to forward request", http.StatusBadGateway)
-			return
+			continue
 		}
-		defer resp.Body.Close()
 
-		w.WriteHeader(resp.StatusCode)
-		io.Copy(w, resp.Body)
-		return
+		if res == nil {
+			continue
+		} else { // node always returns a 200 response
+			fmt.Println("Node called:", url)
+			if res.Body != nil {
+				body, err := io.ReadAll(res.Body)
+				if err != nil {
+					msg = JSONRPCResponse{
+						JSONRPC: "2.0",
+						Error:   &JSONRPCError{Code: -32600, Message: "Parse error. Invalid JSON: " + err.Error()},
+						ID:      1,
+					}
+					json.NewEncoder(w).Encode(msg)
+					return
+				}
+	
+				json.Unmarshal(body, &msg)
+				defer res.Body.Close()
+			}
+
+			if msg.Error != nil || msg.Result != nil { // errors in handling request, all the nodes will return the same
+				json.NewEncoder(w).Encode(msg)
+				return
+			} else if msg.Result == nil {
+				fmt.Println("Result is empty")
+				continue
+			}
+		}
 	}
 
-	resp := JSONRPCResponse{
-		JSONRPC: "2.0",
-		Result:  fmt.Sprintf("Method %s executed successfully", req.Method),
-		ID:      req.ID,
+	if msg.Result == nil { // after all loop, result is still nil?
+		nil_msg := map[string]interface{}{
+			"jsonrpc": msg.JSONRPC,
+			"id":  msg.ID,
+			"result": msg.Result,
+		}
+		json.NewEncoder(w).Encode(nil_msg)
+		return
 	}
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(resp)
-}
+}

gateway/json_rpc_server.go

@@ -148,11 +148,9 @@ func handleWebSocket(w http.ResponseWriter, r *http.Request) {
 		fmt.Printf("Received JSON-RPC WS request: Method=%s, Params=%v, ID=%d\n", req.Method, req.Params, req.ID)
 
 		var height uint64
-		if params, ok := req.Params.(map[string]interface{}); ok {
-			if h, ok := params["height"].(float64); ok {
-				height = uint64(h)
-			}
-		}
+		// if h, ok := req.Params["height"].(float64); ok {
+		// 	height = uint64(h)
+		// }
 
 		if height > 0 {
 			node = config.GetNodebyHeight(height)

gateway/json_rpc_ws_server.go

@@ -356,7 +356,7 @@ func (server *Server) handleJSONRPCRequest(w http.ResponseWriter, r *http.Reques
 					// node returned a 200 response
 					fmt.Println("Node called:", url)
 					if res.Body != nil {
-						defer res.Body.Close()
+						res.Body.Close()
 					}
 
 					for key, values := range res.Header {
@@ -375,7 +375,7 @@ func (server *Server) handleJSONRPCRequest(w http.ResponseWriter, r *http.Reques
 					// node returned a 500 response
 					fmt.Println("Node called:", url)
 					if res.Body != nil {
-						defer res.Body.Close()
+						res.Body.Close()
 					}
 
 					body, err := io.ReadAll(res.Body)