added console command

cmd/geth/main.go

@@ -307,6 +307,7 @@ func console(ctx *cli.Context) {
 	repl := newJSRE(
 		ethereum,
 		ctx.String(utils.JSpathFlag.Name),
+		ctx.GlobalString(utils.IPCPathFlag.Name),
 		ctx.GlobalString(utils.RPCCORSDomainFlag.Name),
 		ctx.GlobalString(utils.IPCPathFlag.Name),
 		true,
@@ -329,6 +330,7 @@ func execJSFiles(ctx *cli.Context) {
 	repl := newJSRE(
 		ethereum,
 		ctx.String(utils.JSpathFlag.Name),
+		ctx.GlobalString(utils.IPCPathFlag.Name),
 		ctx.GlobalString(utils.RPCCORSDomainFlag.Name),
 		ctx.GlobalString(utils.IPCPathFlag.Name),
 		false,

rpc/api/api.go

@@ -27,11 +27,6 @@ var (
 	}, ",")
 )
 
-const (
-	// List with all API's which are offered over the IPC interface by default
-	DefaultIpcApis = "eth"
-)
-
 // Ethereum RPC API interface
 type EthereumApi interface {
 	// API identifier

rpc/api/mergedapi.go

@@ -1,21 +1,27 @@
 package api
 
-import "github.com/ethereum/go-ethereum/rpc/shared"
+import (
+	"github.com/ethereum/go-ethereum/rpc/shared"
+)
+
+const (
+	MergedApiVersion = "1.0"
+)
 
 // combines multiple API's
 type MergedApi struct {
-	apis    []string
+	apis    map[string]string
 	methods map[string]EthereumApi
 }
 
 // create new merged api instance
 func newMergedApi(apis ...EthereumApi) *MergedApi {
 	mergedApi := new(MergedApi)
-	mergedApi.apis = make([]string, len(apis))
+	mergedApi.apis = make(map[string]string, len(apis))
 	mergedApi.methods = make(map[string]EthereumApi)
 
-	for i, api := range apis {
+	for _, api := range apis {
-		mergedApi.apis[i] = api.Name()
+		mergedApi.apis[api.Name()] = api.ApiVersion()
 		for _, method := range api.Methods() {
 			mergedApi.methods[method] = api
 		}
@@ -47,8 +53,12 @@ func (self *MergedApi) Name() string {
 	return MergedApiName
 }
 
+func (self *MergedApi) ApiVersion() string {
+	return MergedApiVersion
+}
+
 func (self *MergedApi) handle(req *shared.Request) (interface{}, error) {
-	if req.Method == "support_apis" { // provided API's
+	if req.Method == "modules" { // provided API's
 		return self.apis, nil
 	}
 

rpc/api/web3.go

@@ -9,7 +9,7 @@ import (
 )
 
 const (
-	Web3Version = "1.0.0"
+	Web3ApiVersion = "1.0"
 )
 
 var (
@@ -63,9 +63,8 @@ func (self *web3Api) Name() string {
 	return Web3ApiName
 }
 
-// Version of the API this instance provides
+func (self *web3Api) ApiVersion() string {
-func (self *web3Api) Version() string {
+	return Web3ApiVersion
-	return Web3Version
 }
 
 // Calculates the sha3 over req.Params.Data

rpc/jeth.go

@@ -11,6 +11,10 @@ import (
 	"github.com/ethereum/go-ethereum/rpc/comms"
 	"github.com/ethereum/go-ethereum/rpc/shared"
 	"github.com/robertkrimen/otto"
+	"github.com/ethereum/go-ethereum/rpc/comms"
+	"github.com/ethereum/go-ethereum/rpc/codec"
+	"github.com/ethereum/go-ethereum/rpc/shared"
+	"reflect"
 )
 
 type Jeth struct {
@@ -40,6 +44,13 @@ func (self *Jeth) Send(call otto.FunctionCall) (response otto.Value) {
 		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 []RpcRequest
 	batch := true
@@ -54,22 +65,43 @@ func (self *Jeth) Send(call otto.FunctionCall) (response otto.Value) {
 	call.Otto.Run("var ret_response = new Array(response_len);")
 
 	for i, req := range reqs {
-		var respif interface{}
+		err := client.Send(&req)
-		err = self.ethApi.GetRequestReply(&req, &respif)
 		if err != nil {
-			fmt.Println("Error response:", err)
+			fmt.Println("Error send request:", err)
 			return self.err(call, -32603, err.Error(), req.Id)
 		}
-		call.Otto.Set("ret_jsonrpc", jsonrpcver)
-		call.Otto.Set("ret_id", req.Id)
 
-		res, _ := json.Marshal(respif)
+		respif, err := client.Recv()
+		if err != nil {
+			fmt.Println("Error recv response:", err)
+			return self.err(call, -32603, err.Error(), req.Id)
+		}
 
-		call.Otto.Set("ret_result", string(res))
+		if res, ok := respif.(shared.SuccessResponse); ok {
-		call.Otto.Set("response_idx", i)
+			call.Otto.Set("ret_id", res.Id)
-		response, err = call.Otto.Run(`
+			call.Otto.Set("ret_jsonrpc", res.Jsonrpc)
-		ret_response[response_idx] = { jsonrpc: ret_jsonrpc, id: ret_id, result: JSON.parse(ret_result) };
+			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 {