status-go/rpc/call_raw.go

217 lines
6.3 KiB
Go
Raw Normal View History

package rpc
import (
"context"
"encoding/json"
gethrpc "github.com/ethereum/go-ethereum/rpc"
)
const (
jsonrpcVersion = "2.0"
errInvalidMessageCode = -32700 // from go-ethereum/rpc/errors.go
)
// for JSON-RPC responses obtained via CallRaw(), we have no way
// to know ID field from actual response. web3.js (primary and
// only user of CallRaw()) will validate response by checking
// ID field for being a number:
// https://github.com/ethereum/web3.js/blob/develop/lib/web3/jsonrpc.js#L66
// thus, we will use zero ID as a workaround of this limitation
var defaultMsgID = json.RawMessage(`0`)
// CallRaw performs a JSON-RPC call with already crafted JSON-RPC body. It
// returns string in JSON format with response (successul or error).
func (c *Client) CallRaw(body string) string {
ctx := context.Background()
return c.callRawContext(ctx, json.RawMessage(body))
}
// jsonrpcMessage represents JSON-RPC message
type jsonrpcMessage struct {
Version string `json:"jsonrpc"`
ID json.RawMessage `json:"id"`
}
type jsonrpcRequest struct {
jsonrpcMessage
Method string `json:"method"`
Params json.RawMessage `json:"params,omitempty"`
}
type jsonrpcSuccessfulResponse struct {
jsonrpcMessage
Result json.RawMessage `json:"result"`
}
type jsonrpcErrorResponse struct {
jsonrpcMessage
Error jsonError `json:"error"`
}
// jsonError represents Error message for JSON-RPC responses.
type jsonError struct {
Code int `json:"code"`
Message string `json:"message"`
Data interface{} `json:"data,omitempty"`
}
// callRawContext performs a JSON-RPC call with already crafted JSON-RPC body and
// given context. It returns string in JSON format with response (successful or error).
//
// TODO(divan): this function exists for compatibility and uses default
// go-ethereum's RPC client under the hood. It adds some unnecessary overhead
// by first marshalling JSON string into object to use with normal Call,
// which is then umarshalled back to the same JSON. The same goes with response.
// This is waste of CPU and memory and should be avoided if possible,
// either by changing exported API (provide only Call, not CallRaw) or
// refactoring go-ethereum's client to allow using raw JSON directly.
func (c *Client) callRawContext(ctx context.Context, body json.RawMessage) string {
if isBatch(body) {
return c.callBatchMethods(ctx, body)
}
return c.callSingleMethod(ctx, body)
}
// callBatchMethods handles batched JSON-RPC requests, calling each of
// individual requests one by one and constructing proper batched response.
//
// See http://www.jsonrpc.org/specification#batch for details.
//
// We can't use gethtrpc.BatchCall here, because each call should go through
// our routing logic and router to corresponding destination.
func (c *Client) callBatchMethods(ctx context.Context, msgs json.RawMessage) string {
var requests []json.RawMessage
err := json.Unmarshal(msgs, &requests)
if err != nil {
return newErrorResponse(errInvalidMessageCode, err, defaultMsgID)
}
// run all methods sequentially, this seems to be main
// objective to use batched requests.
// See: https://github.com/ethereum/wiki/wiki/JavaScript-API#batch-requests
responses := make([]json.RawMessage, len(requests))
for i := range requests {
resp := c.callSingleMethod(ctx, requests[i])
responses[i] = json.RawMessage(resp)
}
data, err := json.Marshal(responses)
if err != nil {
c.log.Error("Failed to marshal batch responses:", "error", err)
return newErrorResponse(errInvalidMessageCode, err, defaultMsgID)
}
return string(data)
}
// callSingleMethod executes single JSON-RPC message and constructs proper response.
func (c *Client) callSingleMethod(ctx context.Context, msg json.RawMessage) string {
// unmarshal JSON body into json-rpc request
method, params, id, err := methodAndParamsFromBody(msg)
if err != nil {
return newErrorResponse(errInvalidMessageCode, err, id)
}
// route and execute
var result json.RawMessage
err = c.CallContext(ctx, &result, method, params...)
// as we have to return original JSON, we have to
// analyze returned error and reconstruct original
// JSON error response.
if err != nil && err != gethrpc.ErrNoResult {
if er, ok := err.(gethrpc.Error); ok {
return newErrorResponse(er.ErrorCode(), err, id)
}
return newErrorResponse(errInvalidMessageCode, err, id)
}
// finally, marshal answer
return newSuccessResponse(result, id)
}
// methodAndParamsFromBody extracts Method and Params of
// JSON-RPC body into values ready to use with ethereum-go's
// RPC client Call() function. A lot of empty interface usage is
// due to the underlying code design :/
func methodAndParamsFromBody(body json.RawMessage) (string, []interface{}, json.RawMessage, error) {
msg, err := unmarshalMessage(body)
if err != nil {
return "", nil, nil, err
}
params := []interface{}{}
if msg.Params != nil {
err = json.Unmarshal(msg.Params, &params)
if err != nil {
return "", nil, nil, err
}
}
return msg.Method, params, msg.ID, nil
}
// unmarshalMessage tries to unmarshal JSON-RPC message.
func unmarshalMessage(body json.RawMessage) (*jsonrpcRequest, error) {
var msg jsonrpcRequest
err := json.Unmarshal(body, &msg)
return &msg, err
}
func newSuccessResponse(result json.RawMessage, id json.RawMessage) string {
if id == nil {
id = defaultMsgID
}
msg := &jsonrpcSuccessfulResponse{
jsonrpcMessage: jsonrpcMessage{
ID: id,
Version: jsonrpcVersion,
},
Result: result,
}
data, err := json.Marshal(msg)
if err != nil {
return newErrorResponse(errInvalidMessageCode, err, id)
}
return string(data)
}
func newErrorResponse(code int, err error, id json.RawMessage) string {
if id == nil {
id = defaultMsgID
}
errMsg := &jsonrpcErrorResponse{
jsonrpcMessage: jsonrpcMessage{
ID: id,
Version: jsonrpcVersion,
},
Error: jsonError{
Code: code,
Message: err.Error(),
},
}
data, _ := json.Marshal(errMsg)
return string(data)
}
// isBatch returns true when the first non-whitespace characters is '['
// code from go-ethereum's rpc client (rpc/client.go)
func isBatch(msg json.RawMessage) bool {
for _, c := range msg {
// skip insignificant whitespace (http://www.ietf.org/rfc/rfc4627.txt)
if c == 0x20 || c == 0x09 || c == 0x0a || c == 0x0d {
continue
}
return c == '['
}
return false
}