Fixed proxy to propagate "correct" errors.

cmd/proxy/proxy.go

@@ -27,13 +27,13 @@ var projectPath string
 func NewProxy(target string) (*Proxy, error) {
 	targetUrl, _ := url.Parse(target)
 
-	client, err := client.Dial(target)
+	c, err := client.Dial(target)
 	if err != nil {
 		return nil, fmt.Errorf("failed calling target ethereum blockchain on %s", target)
 	}
 
 	return &Proxy{
-		client: client,
+		client: c,
 
 		target: targetUrl,
 		proxy:  httputil.NewSingleHostReverseProxy(targetUrl),
@@ -57,6 +57,8 @@ func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		err := p.client.Call(message)
 		if err != nil {
 			fmt.Printf("Failed processing proxy request: %s\n", err)
+
+			continue
 		}
 
 		if message.Method == "eth_getTransactionReceipt" {

ethereum/client/client.go

@@ -62,15 +62,16 @@ func (c *Client) Call(message *jsonrpc2.Message) error {
 
 	req := jsonrpc2.NewRequest(message.Method, params...)
 
-	var resp json.RawMessage
-	if err := c.rpc.CallRequest(&resp, req); err != nil && message.Method != "eth_sendRawTransaction" {
+	resMsg, err := c.rpc.SendRawRequest(req)
+	if err != nil {
 		return fmt.Errorf("proxy calling failed method: [%s], parameters [%s], error: %s",
 			req.Method,
 			req.Params,
 			err)
 	}
 
-	message.Result = resp
+	message.Result = resMsg.Result
+	message.Error = resMsg.Error
 	return nil
 }
 

jsonrpc2/client.go

@@ -122,6 +122,29 @@ func (c *Client) Call(res interface{}, method string, params ...interface{}) err
 }
 
 func (c *Client) CallRequest(res interface{}, req *Request) error {
+	resMsg, err := c.SendRawRequest(req)
+	if err != nil {
+		return err
+	}
+
+	if resMsg.Error != nil {
+		return fmt.Errorf("request failed: [ %d ] %s", resMsg.Error.Code, resMsg.Error.Message)
+	}
+
+	if _, ok := res.(*jsonrpc2.Message); ok {
+		res.(*jsonrpc2.Message).Result = resMsg.Result
+		return nil
+	}
+
+	err = json.Unmarshal(resMsg.Result, res)
+	if err != nil {
+		return fmt.Errorf("read result: %s", err)
+	}
+
+	return nil
+}
+
+func (c *Client) SendRawRequest(req *Request) (*Message, error) {
 	resCh := make(chan *Message, 1)
 	c.setFlying(req.ID, resCh)
 	defer func() {
@@ -130,30 +153,16 @@ func (c *Client) CallRequest(res interface{}, req *Request) error {
 
 	err := c.conn.Write(req)
 	if err != nil {
-		return fmt.Errorf("write message to socket: %s", err)
+		return nil, fmt.Errorf("write message to socket: %s", err)
 	}
 
-	ctx, _ := context.WithTimeout(context.TODO(), 5*time.Second)
+	ctx, _ := context.WithTimeout(context.TODO(), 30*time.Second)
 	select {
 	case <-ctx.Done():
-		return fmt.Errorf("request timed out")
+		return nil, fmt.Errorf("request timed out")
 	case r := <-resCh:
-		if r.Error != nil {
-			return fmt.Errorf("request failed: [ %d ] %s", r.Error.Code, r.Error.Message)
-		}
-
-		if _, ok := res.(*jsonrpc2.Message); ok {
-			res.(*jsonrpc2.Message).Result = r.Result
-			return nil
-		}
-
-		err = json.Unmarshal(r.Result, res)
-		if err != nil {
-			return fmt.Errorf("read result: %s", err)
-		}
+		return r, nil
 	}
-
-	return nil
 }
 
 func (c *Client) Subscribe(id string) (chan *Message, error) {