cleanup comments/code

cmd/geth/js.go

@@ -279,57 +279,6 @@ func (js *jsre) apiBindings(f xeth.Frontend) error {
 	return nil
 }
 
-/*
-func (js *jsre) apiBindings(ipcpath string, f xeth.Frontend) {
-	xe := xeth.New(js.ethereum, f)
-	apiNames, err := js.suportedApis(ipcpath)
-	if err != nil {
-		return
-	}
-
-	ethApi := rpc.NewEthereumApi(xe)
-	jeth := rpc.NewJeth(ethApi, js.re, ipcpath)
-
-	js.re.Set("jeth", struct{}{})
-	t, _ := js.re.Get("jeth")
-	jethObj := t.Object()
-
-	jethObj.Set("send", jeth.Send)
-	jethObj.Set("sendAsync", jeth.Send)
-
-	err := js.re.Compile("bignumber.js", re.BigNumber_JS)
-	if err != nil {
-		utils.Fatalf("Error loading bignumber.js: %v", err)
-	}
-
-	err = js.re.Compile("ethereum.js", re.Web3_JS)
-	if err != nil {
-		utils.Fatalf("Error loading ethereum.js: %v", err)
-	}
-
-	_, err = js.re.Eval("var web3 = require('web3');")
-	if err != nil {
-		utils.Fatalf("Error requiring web3: %v", err)
-	}
-
-	_, err = js.re.Eval("web3.setProvider(jeth)")
-	if err != nil {
-		utils.Fatalf("Error setting web3 provider: %v", err)
-	}
-	_, err = js.re.Eval(`
-var eth = web3.eth;
-var shh = web3.shh;
-var db  = web3.db;
-var net = web3.net;
-  `)
-	if err != nil {
-		utils.Fatalf("Error setting namespaces: %v", err)
-	}
-
-	js.re.Eval(globalRegistrar + "registrar = GlobalRegistrar.at(\"" + globalRegistrarAddr + "\");")
-}
-*/
-
 var ds, _ = docserver.New("/")
 
 func (self *jsre) ConfirmTransaction(tx string) bool {

rpc/comms/inproc.go

@@ -1,21 +1,22 @@
 package comms
 
 import (
-	"github.com/ethereum/go-ethereum/rpc/api"
-	"github.com/ethereum/go-ethereum/rpc/shared"
 	"fmt"
+
+	"github.com/ethereum/go-ethereum/eth"
+	"github.com/ethereum/go-ethereum/rpc/api"
 	"github.com/ethereum/go-ethereum/rpc/codec"
+	"github.com/ethereum/go-ethereum/rpc/shared"
 	"github.com/ethereum/go-ethereum/xeth"
-	"github.com/ethereum/go-ethereum/eth"
 )
 
 type InProcClient struct {
-	api api.EthereumApi
-	codec codec.Codec
-	lastId interface{}
+	api         api.EthereumApi
+	codec       codec.Codec
+	lastId      interface{}
 	lastJsonrpc string
-	lastErr error
-	lastRes interface{}
+	lastErr     error
+	lastRes     interface{}
 }
 
 // Create a new in process client
@@ -49,5 +50,4 @@ func (self *InProcClient) Send(req interface{}) error {
 
 func (self *InProcClient) Recv() (interface{}, error) {
 	return self.lastRes, self.lastErr
-	//return *shared.NewRpcResponse(self.lastId, self.lastJsonrpc, self.lastRes, self.lastErr), nil
 }

rpc/jeth.go

@@ -1,13 +1,13 @@
 package rpc
 
 import (
+	"encoding/json"
+
 	"github.com/ethereum/go-ethereum/jsre"
 	"github.com/ethereum/go-ethereum/rpc/api"
 	"github.com/ethereum/go-ethereum/rpc/comms"
 	"github.com/ethereum/go-ethereum/rpc/shared"
 	"github.com/robertkrimen/otto"
-	"encoding/json"
-	"fmt"
 )
 
 type Jeth struct {
@@ -31,7 +31,6 @@ func (self *Jeth) err(call otto.FunctionCall, code int, msg string, id interface
 	return
 }
 
-
 func (self *Jeth) Send(call otto.FunctionCall) (response otto.Value) {
 	reqif, err := call.Argument(0).Export()
 	if err != nil {
@@ -53,14 +52,12 @@ func (self *Jeth) Send(call otto.FunctionCall) (response otto.Value) {
 
 	for i, req := range reqs {
 		var respif interface{}
-		err := self.client.Send(&req)//self.ethApi.Execute(&req)
+		err := self.client.Send(&req)
 		if err != nil {
-			fmt.Println("Error request:", err)
 			return self.err(call, -32603, err.Error(), req.Id)
 		}
 		respif, err = self.client.Recv()
 		if err != nil {
-			fmt.Println("Error response:", err)
 			return self.err(call, -32603, err.Error(), req.Id)
 		}
 
@@ -91,87 +88,3 @@ func (self *Jeth) Send(call otto.FunctionCall) (response otto.Value) {
 
 	return
 }
-
-/*
-func (self *Jeth) SendIpc(call otto.FunctionCall) (response otto.Value) {
-	reqif, err := call.Argument(0).Export()
-	if err != nil {
-		return self.err(call, -32700, err.Error(), nil)
-	}
-
-	client, err := comms.NewIpcClient(comms.IpcConfig{self.ipcpath}, codec.JSON)
-	if err != nil {
-		fmt.Println("Unable to connect to geth.")
-		return self.err(call, -32603, err.Error(), -1)
-	}
-	defer client.Close()
-
-	jsonreq, err := json.Marshal(reqif)
-	var reqs []shared.Request
-	batch := true
-	err = json.Unmarshal(jsonreq, &reqs)
-	if err != nil {
-		reqs = make([]shared.Request, 1)
-		err = json.Unmarshal(jsonreq, &reqs[0])
-		batch = false
-	}
-
-	call.Otto.Set("response_len", len(reqs))
-	call.Otto.Run("var ret_response = new Array(response_len);")
-
-	for i, req := range reqs {
-		err := client.Send(&req)
-		if err != nil {
-			fmt.Println("Error send request:", err)
-			return self.err(call, -32603, err.Error(), req.Id)
-		}
-
-		respif, err := client.Recv()
-		if err != nil {
-			fmt.Println("Error recv response:", err)
-			return self.err(call, -32603, err.Error(), req.Id)
-		}
-
-		if res, ok := respif.(shared.SuccessResponse); ok {
-			call.Otto.Set("ret_id", res.Id)
-			call.Otto.Set("ret_jsonrpc", res.Jsonrpc)
-			resObj, _ := json.Marshal(res.Result)
-			call.Otto.Set("ret_result", string(resObj))
-			call.Otto.Set("response_idx", i)
-
-			response, err = call.Otto.Run(`
-				ret_response[response_idx] = { jsonrpc: ret_jsonrpc, id: ret_id, result: JSON.parse(ret_result) };
-			`)
-		} else if res, ok := respif.(shared.ErrorResponse); ok {
-			fmt.Printf("Error: %s (%d)\n", res.Error.Message, res.Error.Code)
-
-			call.Otto.Set("ret_id", res.Id)
-			call.Otto.Set("ret_jsonrpc", res.Jsonrpc)
-			call.Otto.Set("ret_error", res.Error)
-			call.Otto.Set("response_idx", i)
-
-			response, _ = call.Otto.Run(`
-				ret_response = { jsonrpc: ret_jsonrpc, id: ret_id, error: ret_error };
-			`)
-			return
-		} else {
-			fmt.Printf("unexpected response\n", reflect.TypeOf(respif))
-		}
-	}
-
-	if !batch {
-		call.Otto.Run("ret_response = ret_response[0];")
-	}
-
-	if call.Argument(1).IsObject() {
-		call.Otto.Set("callback", call.Argument(1))
-		call.Otto.Run(`
-	    if (Object.prototype.toString.call(callback) == '[object Function]') {
-			callback(null, ret_response);
-		}
-		`)
-	}
-
-	return
-}
-*/