From 00f59f5014360cda47e50d9791caf7dd88022c20 Mon Sep 17 00:00:00 2001
From: zelig <viktor.tron@gmail.com>
Date: Wed, 20 May 2015 04:38:20 +0100
Subject: fix eth.sign. now implemented in admin jsre until web3.js has it .

---
 cmd/geth/admin.go   | 25 +++++++++++++++++++++
 cmd/geth/js_test.go |  2 +-
 rpc/api.go          | 20 ++++++++---------
 rpc/args.go         | 64 ++++++++++++++++++++++++++---------------------------
 4 files changed, 68 insertions(+), 43 deletions(-)

diff --git a/cmd/geth/admin.go b/cmd/geth/admin.go
index 53dd0e6ad..523b7c406 100644
--- a/cmd/geth/admin.go
+++ b/cmd/geth/admin.go
@@ -35,6 +35,7 @@ func (js *jsre) adminBindings() {
 	eth := ethO.Object()
 	eth.Set("pendingTransactions", js.pendingTransactions)
 	eth.Set("resend", js.resend)
+	eth.Set("sign", js.sign)
 
 	js.re.Set("admin", struct{}{})
 	t, _ := js.re.Get("admin")
@@ -177,6 +178,30 @@ func (js *jsre) resend(call otto.FunctionCall) otto.Value {
 	return otto.FalseValue()
 }
 
+func (js *jsre) sign(call otto.FunctionCall) otto.Value {
+	if len(call.ArgumentList) != 2 {
+		fmt.Println("requires 2 arguments: eth.sign(signer, data)")
+		return otto.UndefinedValue()
+	}
+	signer, err := call.Argument(0).ToString()
+	if err != nil {
+		fmt.Println(err)
+		return otto.UndefinedValue()
+	}
+
+	data, err := call.Argument(1).ToString()
+	if err != nil {
+		fmt.Println(err)
+		return otto.UndefinedValue()
+	}
+	v, err := js.xeth.Sign(signer, data, false)
+	if err != nil {
+		fmt.Println(err)
+		return otto.UndefinedValue()
+	}
+	return js.re.ToVal(v)
+}
+
 func (js *jsre) debugBlock(call otto.FunctionCall) otto.Value {
 	block, err := js.getBlock(call)
 	if err != nil {
diff --git a/cmd/geth/js_test.go b/cmd/geth/js_test.go
index 71c1fedb9..41e1034e9 100644
--- a/cmd/geth/js_test.go
+++ b/cmd/geth/js_test.go
@@ -230,7 +230,7 @@ func TestSignature(t *testing.T) {
 	defer ethereum.Stop()
 	defer os.RemoveAll(tmp)
 
-	val, err := repl.re.Run(`eth.sign({from: "` + testAddress + `", data: "` + testHash + `"})`)
+	val, err := repl.re.Run(`eth.sign("` + testAddress + `", "` + testHash + `")`)
 
 	// This is a very preliminary test, lacking actual signature verification
 	if err != nil {
diff --git a/rpc/api.go b/rpc/api.go
index 4b705c781..2536ffd74 100644
--- a/rpc/api.go
+++ b/rpc/api.go
@@ -158,16 +158,16 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
 		v := api.xethAtStateNum(args.BlockNumber).CodeAtBytes(args.Address)
 		*reply = newHexData(v)
 
-	case "eth_sign":
-		args := new(NewSigArgs)
-		if err := json.Unmarshal(req.Params, &args); err != nil {
-			return err
-		}
-		v, err := api.xeth().Sign(args.From, args.Data, false)
-		if err != nil {
-			return err
-		}
-		*reply = v
+	// case "eth_sign":
+	// 	args := new(NewSigArgs)
+	// 	if err := json.Unmarshal(req.Params, &args); err != nil {
+	// 		return err
+	// 	}
+	// 	v, err := api.xeth().Sign(args.From, args.Data, false)
+	// 	if err != nil {
+	// 		return err
+	// 	}
+	// 	*reply = v
 
 	case "eth_sendTransaction", "eth_transact":
 		args := new(NewTxArgs)
diff --git a/rpc/args.go b/rpc/args.go
index 686872a59..27824f12c 100644
--- a/rpc/args.go
+++ b/rpc/args.go
@@ -166,45 +166,45 @@ type NewTxArgs struct {
 	BlockNumber int64
 }
 
-type NewSigArgs struct {
-	From string
-	Data string
-}
+// type NewSigArgs struct {
+// 	From string
+// 	Data string
+// }
 
-func (args *NewSigArgs) UnmarshalJSON(b []byte) (err error) {
-	var obj []json.RawMessage
-	var ext struct {
-		From string
-		Data string
-	}
+// func (args *NewSigArgs) UnmarshalJSON(b []byte) (err error) {
+// 	var obj []json.RawMessage
+// 	var ext struct {
+// 		From string
+// 		Data string
+// 	}
 
-	// Decode byte slice to array of RawMessages
-	if err := json.Unmarshal(b, &obj); err != nil {
-		return NewDecodeParamError(err.Error())
-	}
+// 	// Decode byte slice to array of RawMessages
+// 	if err := json.Unmarshal(b, &obj); err != nil {
+// 		return NewDecodeParamError(err.Error())
+// 	}
 
-	// Check for sufficient params
-	if len(obj) < 1 {
-		return NewInsufficientParamsError(len(obj), 1)
-	}
+// 	// Check for sufficient params
+// 	if len(obj) < 1 {
+// 		return NewInsufficientParamsError(len(obj), 1)
+// 	}
 
-	// Decode 0th RawMessage to temporary struct
-	if err := json.Unmarshal(obj[0], &ext); err != nil {
-		return NewDecodeParamError(err.Error())
-	}
+// 	// Decode 0th RawMessage to temporary struct
+// 	if err := json.Unmarshal(obj[0], &ext); err != nil {
+// 		return NewDecodeParamError(err.Error())
+// 	}
 
-	if len(ext.From) == 0 {
-		return NewValidationError("from", "is required")
-	}
+// 	if len(ext.From) == 0 {
+// 		return NewValidationError("from", "is required")
+// 	}
 
-	if len(ext.Data) == 0 {
-		return NewValidationError("data", "is required")
-	}
+// 	if len(ext.Data) == 0 {
+// 		return NewValidationError("data", "is required")
+// 	}
 
-	args.From = ext.From
-	args.Data = ext.Data
-	return nil
-}
+// 	args.From = ext.From
+// 	args.Data = ext.Data
+// 	return nil
+// }
 
 func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
 	var obj []json.RawMessage
-- 
cgit