Remove UnmarshalRawMessages

rpc/args.go

@@ -8,10 +8,18 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
-func blockNumber(raw json.RawMessage, number *int64) (err error) {
+func blockAge(raw interface{}, number *int64) (err error) {
-	var str string
+	// Parse as integer
-	if err = json.Unmarshal(raw, &str); err != nil {
+	num, ok := raw.(int64)
-		return NewDecodeParamError(err.Error())
+	if ok {
+		*number = num
+		return nil
+	}
+
+	// Parse as string/hexstring
+	str, ok := raw.(string)
+	if !ok {
+		return NewDecodeParamError("BlockNumber is not a string")
 	}
 
 	switch str {
@@ -22,6 +30,7 @@ func blockNumber(raw json.RawMessage, number *int64) (err error) {
 	default:
 		*number = common.String2Big(str).Int64()
 	}
+
 	return nil
 }
 
@@ -95,17 +104,43 @@ type NewTxArgs struct {
 }
 
 func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
-	var obj struct{ From, To, Value, Gas, GasPrice, Data string }
+	var obj []json.RawMessage
-	if err = UnmarshalRawMessages(b, &obj, &args.BlockNumber); err != nil {
+	var ext struct{ From, To, Value, Gas, GasPrice, Data string }
-		return err
+
+	// Decode byte slice to array of RawMessages
+	if err := json.Unmarshal(b, &obj); err != nil {
+		return NewDecodeParamError(err.Error())
 	}
 
-	args.From = obj.From
+	// Check for sufficient params
-	args.To = obj.To
+	if len(obj) < 1 {
-	args.Value = common.Big(obj.Value)
+		return NewInsufficientParamsError(len(obj), 1)
-	args.Gas = common.Big(obj.Gas)
+	}
-	args.GasPrice = common.Big(obj.GasPrice)
+
-	args.Data = obj.Data
+	// Decode 0th RawMessage to temporary struct
+	if err := json.Unmarshal(obj[0], &ext); err != nil {
+		return NewDecodeParamError(err.Error())
+	}
+
+	// var ok bool
+	args.From = ext.From
+	args.To = ext.To
+	args.Value = common.String2Big(ext.Value)
+	args.Gas = common.String2Big(ext.Gas)
+	args.GasPrice = common.String2Big(ext.GasPrice)
+	args.Data = ext.Data
+
+	// Check for optional BlockNumber param
+	if len(obj) > 1 {
+		var raw interface{}
+		if err = json.Unmarshal(obj[1], &raw); err != nil {
+			return NewDecodeParamError(err.Error())
+		}
+
+		if err := blockAge(raw, &args.BlockNumber); err != nil {
+			return err
+		}
+	}
 
 	return nil
 }
@@ -116,10 +151,27 @@ type GetStorageArgs struct {
 }
 
 func (args *GetStorageArgs) UnmarshalJSON(b []byte) (err error) {
-	if err = UnmarshalRawMessages(b, &args.Address, &args.BlockNumber); err != nil {
+	var obj []interface{}
+	if err := json.Unmarshal(b, &obj); err != nil {
 		return NewDecodeParamError(err.Error())
 	}
 
+	if len(obj) < 1 {
+		return NewInsufficientParamsError(len(obj), 1)
+	}
+
+	addstr, ok := obj[0].(string)
+	if !ok {
+		return NewDecodeParamError("Address is not a string")
+	}
+	args.Address = addstr
+
+	if len(obj) > 1 {
+		if err := blockAge(obj[1], &args.BlockNumber); err != nil {
+			return err
+		}
+	}
+
 	return nil
 }
 
@@ -137,16 +189,32 @@ type GetStorageAtArgs struct {
 }
 
 func (args *GetStorageAtArgs) UnmarshalJSON(b []byte) (err error) {
-	var obj []string
+	var obj []interface{}
-	if err = UnmarshalRawMessages(b, &obj, &args.BlockNumber); err != nil {
+	if err := json.Unmarshal(b, &obj); err != nil {
 		return NewDecodeParamError(err.Error())
 	}
+
 	if len(obj) < 2 {
 		return NewInsufficientParamsError(len(obj), 2)
 	}
 
-	args.Address = obj[0]
+	addstr, ok := obj[0].(string)
-	args.Key = obj[1]
+	if !ok {
+		return NewDecodeParamError("Address is not a string")
+	}
+	args.Address = addstr
+
+	keystr, ok := obj[1].(string)
+	if !ok {
+		return NewDecodeParamError("Key is not a string")
+	}
+	args.Key = keystr
+
+	if len(obj) > 2 {
+		if err := blockAge(obj[2], &args.BlockNumber); err != nil {
+			return err
+		}
+	}
 
 	return nil
 }
@@ -168,10 +236,27 @@ type GetTxCountArgs struct {
 }
 
 func (args *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
-	if err = UnmarshalRawMessages(b, &args.Address, &args.BlockNumber); err != nil {
+	var obj []interface{}
+	if err := json.Unmarshal(b, &obj); err != nil {
 		return NewDecodeParamError(err.Error())
 	}
 
+	if len(obj) < 1 {
+		return NewInsufficientParamsError(len(obj), 1)
+	}
+
+	addstr, ok := obj[0].(string)
+	if !ok {
+		return NewDecodeParamError("Address is not a string")
+	}
+	args.Address = addstr
+
+	if len(obj) > 1 {
+		if err := blockAge(obj[1], &args.BlockNumber); err != nil {
+			return err
+		}
+	}
+
 	return nil
 }
 
@@ -189,8 +274,7 @@ type GetBalanceArgs struct {
 
 func (args *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
 	var obj []interface{}
-	r := bytes.NewReader(b)
+	if err := json.Unmarshal(b, &obj); err != nil {
-	if err := json.NewDecoder(r).Decode(&obj); err != nil {
 		return NewDecodeParamError(err.Error())
 	}
 
@@ -205,17 +289,11 @@ func (args *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
 	args.Address = addstr
 
 	if len(obj) > 1 {
-		if obj[1].(string) == "latest" {
+		if err := blockAge(obj[1], &args.BlockNumber); err != nil {
-			args.BlockNumber = -1
+			return err
-		} else {
-			args.BlockNumber = common.Big(obj[1].(string)).Int64()
 		}
 	}
 
-	// if err = UnmarshalRawMessages(b, &args.Address, &args.BlockNumber); err != nil {
-	// 	return NewDecodeParamError(err.Error())
-	// }
-
 	return nil
 }
 
@@ -232,10 +310,27 @@ type GetDataArgs struct {
 }
 
 func (args *GetDataArgs) UnmarshalJSON(b []byte) (err error) {
-	if err = UnmarshalRawMessages(b, &args.Address, &args.BlockNumber); err != nil {
+	var obj []interface{}
+	if err := json.Unmarshal(b, &obj); err != nil {
 		return NewDecodeParamError(err.Error())
 	}
 
+	if len(obj) < 1 {
+		return NewInsufficientParamsError(len(obj), 1)
+	}
+
+	addstr, ok := obj[0].(string)
+	if !ok {
+		return NewDecodeParamError("Address is not a string")
+	}
+	args.Address = addstr
+
+	if len(obj) > 1 {
+		if err := blockAge(obj[1], &args.BlockNumber); err != nil {
+			return err
+		}
+	}
+
 	return nil
 }
 
@@ -392,10 +487,6 @@ func (args *FilterOptions) UnmarshalJSON(b []byte) (err error) {
 	return nil
 }
 
-// type FilterChangedArgs struct {
-// 	n int
-// }
-
 type DbArgs struct {
 	Database string
 	Key      string
@@ -578,31 +669,3 @@ func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
 
 	return nil
 }
-
-// func (req *RpcRequest) ToRegisterArgs() (string, error) {
-// 	if len(req.Params) < 1 {
-// 		return "", errArguments
-// 	}
-
-// 	var args string
-// 	err := json.Unmarshal(req.Params, &args)
-// 	if err != nil {
-// 		return "", err
-// 	}
-
-// 	return args, nil
-// }
-
-// func (req *RpcRequest) ToWatchTxArgs() (string, error) {
-// 	if len(req.Params) < 1 {
-// 		return "", errArguments
-// 	}
-
-// 	var args string
-// 	err := json.Unmarshal(req.Params, &args)
-// 	if err != nil {
-// 		return "", err
-// 	}
-
-// 	return args, nil
-// }

rpc/util.go

@@ -17,9 +17,6 @@
 package rpc
 
 import (
-	"encoding/json"
-	"fmt"
-	"reflect"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -30,65 +27,6 @@ import (
 
 var rpclogger = logger.NewLogger("RPC")
 
-// Unmarshal state is a helper method which has the ability to decode messsages
-// that use the `defaultBlock` (https://github.com/ethereum/wiki/wiki/JSON-RPC#the-default-block-parameter)
-// For example a `call`: [{to: "0x....", data:"0x..."}, "latest"]. The first argument is the transaction
-// message and the second one refers to the block height (or state) to which to apply this `call`.
-func UnmarshalRawMessages(b []byte, iface interface{}, number *int64) (err error) {
-	var data []json.RawMessage
-	if err = json.Unmarshal(b, &data); err != nil && len(data) == 0 {
-		return NewDecodeParamError(err.Error())
-	}
-
-	// Hrm... Occurs when no params
-	if len(data) == 0 {
-		return NewDecodeParamError("No data")
-	}
-
-	// Number index determines the index in the array for a possible block number
-	numberIndex := 0
-
-	value := reflect.ValueOf(iface)
-	rvalue := reflect.Indirect(value)
-
-	switch rvalue.Kind() {
-	case reflect.Slice:
-		// This is a bit of a cheat, but `data` is expected to be larger than 2 if iface is a slice
-		if number != nil {
-			numberIndex = len(data) - 1
-		} else {
-			numberIndex = len(data)
-		}
-
-		slice := reflect.MakeSlice(rvalue.Type(), numberIndex, numberIndex)
-		for i, raw := range data[0:numberIndex] {
-			v := slice.Index(i).Interface()
-			if err = json.Unmarshal(raw, &v); err != nil {
-				fmt.Println(err, v)
-				return err
-			}
-			slice.Index(i).Set(reflect.ValueOf(v))
-		}
-		reflect.Indirect(rvalue).Set(slice) //value.Set(slice)
-	case reflect.Struct:
-		fallthrough
-	default:
-		if err = json.Unmarshal(data[0], iface); err != nil {
-			return NewDecodeParamError(err.Error())
-		}
-		numberIndex = 1
-	}
-
-	// <0 index means out of bound for block number
-	if numberIndex >= 0 && len(data) > numberIndex {
-		if err = blockNumber(data[numberIndex], number); err != nil {
-			return NewDecodeParamError(err.Error())
-		}
-	}
-
-	return nil
-}
-
 type Log struct {
 	Address string   `json:"address"`
 	Topic   []string `json:"topic"`