aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--core/filter.go23
-rw-r--r--rpc/api.go89
-rw-r--r--rpc/args.go453
-rw-r--r--rpc/args_test.go1350
-rw-r--r--rpc/messages.go16
-rw-r--r--rpc/messages_test.go9
-rw-r--r--xeth/xeth.go42
7 files changed, 1612 insertions, 370 deletions
diff --git a/core/filter.go b/core/filter.go
index ba5d5e14e..1dca5501d 100644
--- a/core/filter.go
+++ b/core/filter.go
@@ -12,17 +12,6 @@ type AccountChange struct {
Address, StateAddress []byte
}
-type FilterOptions struct {
- Earliest int64
- Latest int64
-
- Address []common.Address
- Topics [][]common.Hash
-
- Skip int
- Max int
-}
-
// Filtering interface
type Filter struct {
eth Backend
@@ -44,18 +33,6 @@ func NewFilter(eth Backend) *Filter {
return &Filter{eth: eth}
}
-// SetOptions copies the filter options to the filter it self. The reason for this "silly" copy
-// is simply because named arguments in this case is extremely nice and readable.
-func (self *Filter) SetOptions(options *FilterOptions) {
- self.earliest = options.Earliest
- self.latest = options.Latest
- self.skip = options.Skip
- self.max = options.Max
- self.address = options.Address
- self.topics = options.Topics
-
-}
-
// Set the earliest and latest block for filtering.
// -1 = latest block (i.e., the current block)
// hash = particular hash from-to
diff --git a/rpc/api.go b/rpc/api.go
index f2915f658..8803c28dd 100644
--- a/rpc/api.go
+++ b/rpc/api.go
@@ -6,7 +6,6 @@ import (
"sync"
"github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/xeth"
)
@@ -82,10 +81,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
-
v := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Balance()
*reply = common.ToHex(v.Bytes())
case "eth_getStorage", "eth_storageAt":
@@ -94,19 +89,12 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
-
*reply = api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Storage()
case "eth_getStorageAt":
args := new(GetStorageAtArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
state := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address)
value := state.StorageString(args.Key)
@@ -118,11 +106,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
- err := args.requirements()
- if err != nil {
- return err
- }
-
*reply = api.xethAtStateNum(args.BlockNumber).TxCountAt(args.Address)
case "eth_getBlockTransactionCountByHash":
args := new(GetBlockByHashArgs)
@@ -163,9 +146,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
*reply = api.xethAtStateNum(args.BlockNumber).CodeAt(args.Address)
case "eth_sendTransaction", "eth_transact":
args := new(NewTxArgs)
@@ -173,10 +153,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
-
v, err := api.xeth().Transact(args.From, args.To, args.Value.String(), args.Gas.String(), args.GasPrice.String(), args.Data)
if err != nil {
return err
@@ -267,8 +243,8 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return NewValidationError("Index", "does not exist")
}
- uhash := br.Uncles[args.Index].Hex()
- uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash))
+ uhash := br.Uncles[args.Index]
+ uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.Hex()))
*reply = uncle
case "eth_getUncleByBlockNumberAndIndex":
@@ -285,8 +261,8 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return NewValidationError("Index", "does not exist")
}
- uhash := v.Uncles[args.Index].Hex()
- uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash))
+ uhash := v.Uncles[args.Index]
+ uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.Hex()))
*reply = uncle
case "eth_getCompilers":
@@ -300,18 +276,13 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
- opts := toFilterOptions(args)
- id := api.xeth().RegisterFilter(opts)
+ id := api.xeth().RegisterFilter(args.Earliest, args.Latest, args.Skip, args.Max, args.Address, args.Topics)
*reply = common.ToHex(big.NewInt(int64(id)).Bytes())
case "eth_newBlockFilter":
args := new(FilterStringArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
-
id := api.xeth().NewFilterString(args.Word)
*reply = common.ToHex(big.NewInt(int64(id)).Bytes())
case "eth_uninstallFilter":
@@ -337,8 +308,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- opts := toFilterOptions(args)
- *reply = NewLogsRes(api.xeth().AllLogs(opts))
+ *reply = NewLogsRes(api.xeth().AllLogs(args.Earliest, args.Latest, args.Skip, args.Max, args.Address, args.Topics))
case "eth_getWork":
api.xeth().SetMining(true)
*reply = api.xeth().RemoteMining().GetWork()
@@ -347,7 +317,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- *reply = api.xeth().RemoteMining().SubmitWork(args.Nonce, args.Digest, args.Header)
+ *reply = api.xeth().RemoteMining().SubmitWork(args.Nonce, common.HexToHash(args.Digest), common.HexToHash(args.Header))
case "db_putString":
args := new(DbArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
@@ -433,7 +403,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
opts := new(xeth.Options)
- opts.From = args.From
+ // opts.From = args.From
opts.To = args.To
opts.Topics = args.Topics
id := api.xeth().NewWhisperFilter(opts)
@@ -483,46 +453,3 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
rpclogger.DebugDetailf("Reply: %T %s", reply, reply)
return nil
}
-
-func toFilterOptions(options *BlockFilterArgs) *core.FilterOptions {
- var opts core.FilterOptions
-
- // Convert optional address slice/string to byte slice
- if str, ok := options.Address.(string); ok {
- opts.Address = []common.Address{common.HexToAddress(str)}
- } else if slice, ok := options.Address.([]interface{}); ok {
- bslice := make([]common.Address, len(slice))
- for i, addr := range slice {
- if saddr, ok := addr.(string); ok {
- bslice[i] = common.HexToAddress(saddr)
- }
- }
- opts.Address = bslice
- }
-
- opts.Earliest = options.Earliest
- opts.Latest = options.Latest
-
- topics := make([][]common.Hash, len(options.Topics))
- for i, topicDat := range options.Topics {
- if slice, ok := topicDat.([]interface{}); ok {
- topics[i] = make([]common.Hash, len(slice))
- for j, topic := range slice {
- topics[i][j] = common.HexToHash(topic.(string))
- }
- } else if str, ok := topicDat.(string); ok {
- topics[i] = []common.Hash{common.HexToHash(str)}
- }
- }
- opts.Topics = topics
-
- return &opts
-}
-
-/*
- Work() chan<- *types.Block
- SetWorkCh(chan<- Work)
- Stop()
- Start()
- Rate() uint64
-*/
diff --git a/rpc/args.go b/rpc/args.go
index 1928ec218..a075f1a59 100644
--- a/rpc/args.go
+++ b/rpc/args.go
@@ -3,14 +3,27 @@ package rpc
import (
"bytes"
"encoding/json"
- "errors"
+ // "errors"
"fmt"
"math/big"
"github.com/ethereum/go-ethereum/common"
)
-func blockHeight(raw interface{}, number *int64) (err error) {
+const (
+ defaultLogLimit = 100
+ defaultLogOffset = 0
+)
+
+func blockHeightFromJson(msg json.RawMessage, number *int64) error {
+ var raw interface{}
+ if err := json.Unmarshal(msg, &raw); err != nil {
+ return NewDecodeParamError(err.Error())
+ }
+ return blockHeight(raw, number)
+}
+
+func blockHeight(raw interface{}, number *int64) error {
// Parse as integer
num, ok := raw.(float64)
if ok {
@@ -21,7 +34,7 @@ func blockHeight(raw interface{}, number *int64) (err error) {
// Parse as string/hexstring
str, ok := raw.(string)
if !ok {
- return NewDecodeParamError("BlockNumber is not a string")
+ return NewInvalidTypeError("", "not a number or string")
}
switch str {
@@ -36,26 +49,55 @@ func blockHeight(raw interface{}, number *int64) (err error) {
return nil
}
-func toNumber(v interface{}) (int64, error) {
- var str string
- if v != nil {
- var ok bool
- str, ok = v.(string)
- if !ok {
- return 0, errors.New("is not a string or undefined")
- }
- } else {
- str = "latest"
+func numString(raw interface{}, number *int64) error {
+ // Parse as integer
+ num, ok := raw.(float64)
+ if ok {
+ *number = int64(num)
+ return nil
}
- switch str {
- case "latest":
- return -1, nil
- default:
- return int64(common.Big(v.(string)).Int64()), nil
+ // Parse as string/hexstring
+ str, ok := raw.(string)
+ if !ok {
+ return NewInvalidTypeError("", "not a number or string")
}
+ *number = common.String2Big(str).Int64()
+
+ return nil
}
+// func toNumber(v interface{}) (int64, error) {
+// var str string
+// if v != nil {
+// var ok bool
+// str, ok = v.(string)
+// if !ok {
+// return 0, errors.New("is not a string or undefined")
+// }
+// } else {
+// str = "latest"
+// }
+
+// switch str {
+// case "latest":
+// return -1, nil
+// default:
+// return int64(common.Big(v.(string)).Int64()), nil
+// }
+// }
+
+// func hashString(raw interface{}, hash *string) error {
+// argstr, ok := raw.(string)
+// if !ok {
+// return NewInvalidTypeError("", "not a string")
+// }
+// v := common.IsHex(argstr)
+// hash = &argstr
+
+// return nil
+// }
+
type GetBlockByHashArgs struct {
BlockHash string
IncludeTxs bool
@@ -74,7 +116,7 @@ func (args *GetBlockByHashArgs) UnmarshalJSON(b []byte) (err error) {
argstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("BlockHash not a string")
+ return NewInvalidTypeError("blockHash", "not a string")
}
args.BlockHash = argstr
@@ -103,8 +145,10 @@ func (args *GetBlockByNumberArgs) UnmarshalJSON(b []byte) (err error) {
if v, ok := obj[0].(float64); ok {
args.BlockNumber = int64(v)
+ } else if v, ok := obj[0].(string); ok {
+ args.BlockNumber = common.Big(v).Int64()
} else {
- args.BlockNumber = common.Big(obj[0].(string)).Int64()
+ return NewInvalidTypeError("blockNumber", "not a number or string")
}
if len(obj) > 1 {
@@ -127,7 +171,14 @@ type NewTxArgs struct {
func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
var obj []json.RawMessage
- var ext struct{ From, To, Value, Gas, GasPrice, Data string }
+ var ext struct {
+ From string
+ To string
+ Value interface{}
+ Gas interface{}
+ GasPrice interface{}
+ Data string
+ }
// Decode byte slice to array of RawMessages
if err := json.Unmarshal(b, &obj); err != nil {
@@ -144,33 +195,49 @@ func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
return NewDecodeParamError(err.Error())
}
- // var ok bool
+ if len(ext.From) == 0 {
+ return NewValidationError("from", "is required")
+ }
+
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())
+ var num int64
+ if ext.Value == nil {
+ return NewValidationError("value", "is required")
+ } else {
+ if err := numString(ext.Value, &num); err != nil {
+ return err
}
+ }
+ args.Value = big.NewInt(num)
- if err := blockHeight(raw, &args.BlockNumber); err != nil {
+ if ext.Gas == nil {
+ return NewValidationError("gas", "is required")
+ } else {
+ if err := numString(ext.Gas, &num); err != nil {
return err
}
}
+ args.Gas = big.NewInt(num)
- return nil
-}
+ if ext.GasPrice == nil {
+ return NewValidationError("gasprice", "is required")
+ } else {
+ if err := numString(ext.GasPrice, &num); err != nil {
+ return err
+ }
+ }
+ args.GasPrice = big.NewInt(num)
-func (args *NewTxArgs) requirements() error {
- if len(args.From) == 0 {
- return NewValidationError("From", "Is required")
+ // Check for optional BlockNumber param
+ if len(obj) > 1 {
+ if err := blockHeightFromJson(obj[1], &args.BlockNumber); err != nil {
+ return err
+ }
}
+
return nil
}
@@ -191,7 +258,7 @@ func (args *GetStorageArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Address is not a string")
+ return NewInvalidTypeError("address", "not a string")
}
args.Address = addstr
@@ -204,13 +271,6 @@ func (args *GetStorageArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *GetStorageArgs) requirements() error {
- if len(args.Address) == 0 {
- return NewValidationError("Address", "cannot be blank")
- }
- return nil
-}
-
type GetStorageAtArgs struct {
Address string
Key string
@@ -229,13 +289,13 @@ func (args *GetStorageAtArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Address is not a string")
+ return NewInvalidTypeError("address", "not a string")
}
args.Address = addstr
keystr, ok := obj[1].(string)
if !ok {
- return NewDecodeParamError("Key is not a string")
+ return NewInvalidTypeError("key", "not a string")
}
args.Key = keystr
@@ -248,17 +308,6 @@ func (args *GetStorageAtArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *GetStorageAtArgs) requirements() error {
- if len(args.Address) == 0 {
- return NewValidationError("Address", "cannot be blank")
- }
-
- if len(args.Key) == 0 {
- return NewValidationError("Key", "cannot be blank")
- }
- return nil
-}
-
type GetTxCountArgs struct {
Address string
BlockNumber int64
@@ -276,7 +325,7 @@ func (args *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Address is not a string")
+ return NewInvalidTypeError("address", "not a string")
}
args.Address = addstr
@@ -289,13 +338,6 @@ func (args *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *GetTxCountArgs) requirements() error {
- if len(args.Address) == 0 {
- return NewValidationError("Address", "cannot be blank")
- }
- return nil
-}
-
type GetBalanceArgs struct {
Address string
BlockNumber int64
@@ -313,7 +355,7 @@ func (args *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Address is not a string")
+ return NewInvalidTypeError("address", "not a string")
}
args.Address = addstr
@@ -326,13 +368,6 @@ func (args *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *GetBalanceArgs) requirements() error {
- if len(args.Address) == 0 {
- return NewValidationError("Address", "cannot be blank")
- }
- return nil
-}
-
type GetDataArgs struct {
Address string
BlockNumber int64
@@ -350,7 +385,7 @@ func (args *GetDataArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Address is not a string")
+ return NewInvalidTypeError("address", "not a string")
}
args.Address = addstr
@@ -363,13 +398,6 @@ func (args *GetDataArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *GetDataArgs) requirements() error {
- if len(args.Address) == 0 {
- return NewValidationError("Address", "cannot be blank")
- }
- return nil
-}
-
type BlockNumIndexArgs struct {
BlockNumber int64
Index int64
@@ -386,16 +414,14 @@ func (args *BlockNumIndexArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- arg0, ok := obj[0].(string)
- if !ok {
- return NewDecodeParamError("BlockNumber is not string")
+ if err := blockHeight(obj[0], &args.BlockNumber); err != nil {
+ return err
}
- args.BlockNumber = common.Big(arg0).Int64()
if len(obj) > 1 {
arg1, ok := obj[1].(string)
if !ok {
- return NewDecodeParamError("Index not a string")
+ return NewInvalidTypeError("index", "not a string")
}
args.Index = common.Big(arg1).Int64()
}
@@ -421,14 +447,14 @@ func (args *HashIndexArgs) UnmarshalJSON(b []byte) (err error) {
arg0, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Hash not a string")
+ return NewInvalidTypeError("hash", "not a string")
}
args.Hash = arg0
if len(obj) > 1 {
arg1, ok := obj[1].(string)
if !ok {
- return NewDecodeParamError("Index not a string")
+ return NewInvalidTypeError("index", "not a string")
}
args.Index = common.Big(arg1).Int64()
}
@@ -450,28 +476,32 @@ func (args *Sha3Args) UnmarshalJSON(b []byte) (err error) {
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
- args.Data = obj[0].(string)
+ argstr, ok := obj[0].(string)
+ if !ok {
+ return NewInvalidTypeError("data", "is not a string")
+ }
+ args.Data = argstr
return nil
}
type BlockFilterArgs struct {
Earliest int64
Latest int64
- Address interface{}
- Topics []interface{}
+ Address []string
+ Topics [][]string
Skip int
Max int
}
func (args *BlockFilterArgs) UnmarshalJSON(b []byte) (err error) {
var obj []struct {
- FromBlock interface{} `json:"fromBlock"`
- ToBlock interface{} `json:"toBlock"`
- Limit string `json:"limit"`
- Offset string `json:"offset"`
- Address string `json:"address"`
- Topics []interface{} `json:"topics"`
+ FromBlock interface{} `json:"fromBlock"`
+ ToBlock interface{} `json:"toBlock"`
+ Limit interface{} `json:"limit"`
+ Offset interface{} `json:"offset"`
+ Address interface{} `json:"address"`
+ Topics interface{} `json:"topics"`
}
if err = json.Unmarshal(b, &obj); err != nil {
@@ -482,19 +512,113 @@ func (args *BlockFilterArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- args.Earliest, err = toNumber(obj[0].ToBlock)
- if err != nil {
- return NewDecodeParamError(fmt.Sprintf("FromBlock %v", err))
+ // args.Earliest, err = toNumber(obj[0].ToBlock)
+ // if err != nil {
+ // return NewDecodeParamError(fmt.Sprintf("FromBlock %v", err))
+ // }
+ // args.Latest, err = toNumber(obj[0].FromBlock)
+ // if err != nil {
+ // return NewDecodeParamError(fmt.Sprintf("ToBlock %v", err))
+
+ var num int64
+
+ // if blank then latest
+ if obj[0].FromBlock == nil {
+ num = -1
+ } else {
+ if err := blockHeight(obj[0].FromBlock, &num); err != nil {
+ return err
+ }
}
- args.Latest, err = toNumber(obj[0].FromBlock)
- if err != nil {
- return NewDecodeParamError(fmt.Sprintf("ToBlock %v", err))
+ // if -2 or other "silly" number, use latest
+ if num < 0 {
+ args.Earliest = -1 //latest block
+ } else {
+ args.Earliest = num
}
- args.Max = int(common.Big(obj[0].Limit).Int64())
- args.Skip = int(common.Big(obj[0].Offset).Int64())
- args.Address = obj[0].Address
- args.Topics = obj[0].Topics
+ // if blank than latest
+ if obj[0].ToBlock == nil {
+ num = -1
+ } else {
+ if err := blockHeight(obj[0].ToBlock, &num); err != nil {
+ return err
+ }
+ }
+ args.Latest = num
+
+ if obj[0].Limit == nil {
+ num = defaultLogLimit
+ } else {
+ if err := numString(obj[0].Limit, &num); err != nil {
+ return err
+ }
+ }
+ args.Max = int(num)
+
+ if obj[0].Offset == nil {
+ num = defaultLogOffset
+ } else {
+ if err := numString(obj[0].Offset, &num); err != nil {
+ return err
+ }
+ }
+ args.Skip = int(num)
+
+ if obj[0].Address != nil {
+ marg, ok := obj[0].Address.([]interface{})
+ if ok {
+ v := make([]string, len(marg))
+ for i, arg := range marg {
+ argstr, ok := arg.(string)
+ if !ok {
+ return NewInvalidTypeError(fmt.Sprintf("address[%d]", i), "is not a string")
+ }
+ v[i] = argstr
+ }
+ args.Address = v
+ } else {
+ argstr, ok := obj[0].Address.(string)
+ if ok {
+ v := make([]string, 1)
+ v[0] = argstr
+ args.Address = v
+ } else {
+ return NewInvalidTypeError("address", "is not a string or array")
+ }
+ }
+ }
+
+ if obj[0].Topics != nil {
+ other, ok := obj[0].Topics.([]interface{})
+ if ok {
+ topicdbl := make([][]string, len(other))
+ for i, iv := range other {
+ if argstr, ok := iv.(string); ok {
+ // Found a string, push into first element of array
+ topicsgl := make([]string, 1)
+ topicsgl[0] = argstr
+ topicdbl[i] = topicsgl
+ } else if argarray, ok := iv.([]interface{}); ok {
+ // Found an array of other
+ topicdbl[i] = make([]string, len(argarray))
+ for j, jv := range argarray {
+ if v, ok := jv.(string); ok {
+ topicdbl[i][j] = v
+ } else {
+ return NewInvalidTypeError(fmt.Sprintf("topic[%d][%d]", i, j), "is not a string")
+ }
+ }
+ } else {
+ return NewInvalidTypeError(fmt.Sprintf("topic[%d]", i), "not a string or array")
+ }
+ }
+ args.Topics = topicdbl
+ return nil
+ } else {
+ return NewInvalidTypeError("topic", "is not a string or array")
+ }
+ }
return nil
}
@@ -519,19 +643,19 @@ func (args *DbArgs) UnmarshalJSON(b []byte) (err error) {
var ok bool
if objstr, ok = obj[0].(string); !ok {
- return NewDecodeParamError("Database is not a string")
+ return NewInvalidTypeError("database", "not a string")
}
args.Database = objstr
if objstr, ok = obj[1].(string); !ok {
- return NewDecodeParamError("Key is not a string")
+ return NewInvalidTypeError("key", "not a string")
}
args.Key = objstr
if len(obj) > 2 {
objstr, ok = obj[2].(string)
if !ok {
- return NewDecodeParamError("Value is not a string")
+ return NewInvalidTypeError("value", "not a string")
}
args.Value = []byte(objstr)
@@ -570,19 +694,19 @@ func (args *DbHexArgs) UnmarshalJSON(b []byte) (err error) {
var ok bool
if objstr, ok = obj[0].(string); !ok {
- return NewDecodeParamError("Database is not a string")
+ return NewInvalidTypeError("database", "not a string")
}
args.Database = objstr
if objstr, ok = obj[1].(string); !ok {
- return NewDecodeParamError("Key is not a string")
+ return NewInvalidTypeError("key", "not a string")
}
args.Key = objstr
if len(obj) > 2 {
objstr, ok = obj[2].(string)
if !ok {
- return NewDecodeParamError("Value is not a string")
+ return NewInvalidTypeError("value", "not a string")
}
args.Value = common.FromHex(objstr)
@@ -616,8 +740,8 @@ func (args *WhisperMessageArgs) UnmarshalJSON(b []byte) (err error) {
To string
From string
Topics []string
- Priority string
- Ttl string
+ Priority interface{}
+ Ttl interface{}
}
if err = json.Unmarshal(b, &obj); err != nil {
@@ -631,8 +755,17 @@ func (args *WhisperMessageArgs) UnmarshalJSON(b []byte) (err error) {
args.To = obj[0].To
args.From = obj[0].From
args.Topics = obj[0].Topics
- args.Priority = uint32(common.Big(obj[0].Priority).Int64())
- args.Ttl = uint32(common.Big(obj[0].Ttl).Int64())
+
+ var num int64
+ if err := numString(obj[0].Priority, &num); err != nil {
+ return err
+ }
+ args.Priority = uint32(num)
+
+ if err := numString(obj[0].Ttl, &num); err != nil {
+ return err
+ }
+ args.Ttl = uint32(num)
return nil
}
@@ -643,14 +776,18 @@ type CompileArgs struct {
func (args *CompileArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
- r := bytes.NewReader(b)
- if err := json.NewDecoder(r).Decode(&obj); err != nil {
+ if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
- if len(obj) > 0 {
- args.Source = obj[0].(string)
+ if len(obj) < 1 {
+ return NewInsufficientParamsError(len(obj), 1)
}
+ argstr, ok := obj[0].(string)
+ if !ok {
+ return NewInvalidTypeError("arg0", "is not a string")
+ }
+ args.Source = argstr
return nil
}
@@ -673,20 +810,15 @@ func (args *FilterStringArgs) UnmarshalJSON(b []byte) (err error) {
var argstr string
argstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Filter is not a string")
+ return NewInvalidTypeError("filter", "not a string")
}
- args.Word = argstr
-
- return nil
-}
-
-func (args *FilterStringArgs) requirements() error {
- switch args.Word {
+ switch argstr {
case "latest", "pending":
break
default:
return NewValidationError("Word", "Must be `latest` or `pending`")
}
+ args.Word = argstr
return nil
}
@@ -695,9 +827,8 @@ type FilterIdArgs struct {
}
func (args *FilterIdArgs) UnmarshalJSON(b []byte) (err error) {
- var obj []string
- r := bytes.NewReader(b)
- if err := json.NewDecoder(r).Decode(&obj); err != nil {
+ var obj []interface{}
+ if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
@@ -705,7 +836,11 @@ func (args *FilterIdArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- args.Id = int(common.Big(obj[0]).Int64())
+ var num int64
+ if err := numString(obj[0], &num); err != nil {
+ return err
+ }
+ args.Id = int(num)
return nil
}
@@ -715,9 +850,8 @@ type WhisperIdentityArgs struct {
}
func (args *WhisperIdentityArgs) UnmarshalJSON(b []byte) (err error) {
- var obj []string
- r := bytes.NewReader(b)
- if err := json.NewDecoder(r).Decode(&obj); err != nil {
+ var obj []interface{}
+ if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
@@ -725,7 +859,14 @@ func (args *WhisperIdentityArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- args.Identity = obj[0]
+ argstr, ok := obj[0].(string)
+ if !ok {
+ return NewInvalidTypeError("arg0", "not a string")
+ }
+ // if !common.IsHex(argstr) {
+ // return NewValidationError("arg0", "not a hexstring")
+ // }
+ args.Identity = argstr
return nil
}
@@ -738,9 +879,8 @@ type WhisperFilterArgs struct {
func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
var obj []struct {
- To string
- From string
- Topics []string
+ To interface{}
+ Topics []interface{}
}
if err = json.Unmarshal(b, &obj); err != nil {
@@ -751,17 +891,30 @@ func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- args.To = obj[0].To
- args.From = obj[0].From
- args.Topics = obj[0].Topics
+ var argstr string
+ argstr, ok := obj[0].To.(string)
+ if !ok {
+ return NewInvalidTypeError("to", "is not a string")
+ }
+ args.To = argstr
+
+ t := make([]string, len(obj[0].Topics))
+ for i, j := range obj[0].Topics {
+ argstr, ok := j.(string)
+ if !ok {
+ return NewInvalidTypeError("topics["+string(i)+"]", "is not a string")
+ }
+ t[i] = argstr
+ }
+ args.Topics = t
return nil
}
type SubmitWorkArgs struct {
Nonce uint64
- Header common.Hash
- Digest common.Hash
+ Header string
+ Digest string
}
func (args *SubmitWorkArgs) UnmarshalJSON(b []byte) (err error) {
@@ -777,21 +930,21 @@ func (args *SubmitWorkArgs) UnmarshalJSON(b []byte) (err error) {
var objstr string
var ok bool
if objstr, ok = obj[0].(string); !ok {
- return NewDecodeParamError("Nonce is not a string")
+ return NewInvalidTypeError("nonce", "not a string")
}
args.Nonce = common.String2Big(objstr).Uint64()
if objstr, ok = obj[1].(string); !ok {
- return NewDecodeParamError("Header is not a string")
+ return NewInvalidTypeError("header", "not a string")
}
- args.Header = common.HexToHash(objstr)
+ args.Header = objstr
if objstr, ok = obj[2].(string); !ok {
- return NewDecodeParamError("Digest is not a string")
+ return NewInvalidTypeError("digest", "not a string")
}
- args.Digest = common.HexToHash(objstr)
+ args.Digest = objstr
return nil
}
diff --git a/rpc/args_test.go b/rpc/args_test.go
index 5cbafd4b2..602631b67 100644
--- a/rpc/args_test.go
+++ b/rpc/args_test.go
@@ -3,12 +3,63 @@ package rpc
import (
"bytes"
"encoding/json"
+ "fmt"
"math/big"
"testing"
-
- "github.com/ethereum/go-ethereum/common"
)
+func ExpectValidationError(err error) string {
+ var str string
+ switch err.(type) {
+ case nil:
+ str = "Expected error but didn't get one"
+ case *ValidationError:
+ break
+ default:
+ str = fmt.Sprintf("Expected *rpc.ValidationError but got %T with message `%s`", err, err.Error())
+ }
+ return str
+}
+
+func ExpectInvalidTypeError(err error) string {
+ var str string
+ switch err.(type) {
+ case nil:
+ str = "Expected error but didn't get one"
+ case *InvalidTypeError:
+ break
+ default:
+ str = fmt.Sprintf("Expected *rpc.InvalidTypeError but got %T with message `%s`", err, err.Error())
+ }
+ return str
+}
+
+func ExpectInsufficientParamsError(err error) string {
+ var str string
+ switch err.(type) {
+ case nil:
+ str = "Expected error but didn't get one"
+ case *InsufficientParamsError:
+ break
+ default:
+ str = fmt.Sprintf("Expected *rpc.InsufficientParamsError but got %T with message %s", err, err.Error())
+ }
+ return str
+}
+
+func ExpectDecodeParamError(err error) string {
+ var str string
+ switch err.(type) {
+ case nil:
+ str = "Expected error but didn't get one"
+ case *DecodeParamError:
+ break
+ default:
+ str = fmt.Sprintf("Expected *rpc.DecodeParamError but got %T with message `%s`", err, err.Error())
+ }
+ return str
+}
+
func TestSha3(t *testing.T) {
input := `["0x68656c6c6f20776f726c64"]`
expected := "0x68656c6c6f20776f726c64"
@@ -21,6 +72,35 @@ func TestSha3(t *testing.T) {
}
}
+func TestSha3ArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(Sha3Args)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestSha3ArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(Sha3Args)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+func TestSha3ArgsDataInvalid(t *testing.T) {
+ input := `[4]`
+
+ args := new(Sha3Args)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestGetBalanceArgs(t *testing.T) {
input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "0x1f"]`
expected := new(GetBalanceArgs)
@@ -32,10 +112,6 @@ func TestGetBalanceArgs(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if args.Address != expected.Address {
t.Errorf("Address should be %v but is %v", expected.Address, args.Address)
}
@@ -56,10 +132,6 @@ func TestGetBalanceArgsLatest(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if args.Address != expected.Address {
t.Errorf("Address should be %v but is %v", expected.Address, args.Address)
}
@@ -69,15 +141,44 @@ func TestGetBalanceArgsLatest(t *testing.T) {
}
}
-func TestGetBalanceEmptyArgs(t *testing.T) {
+func TestGetBalanceArgsEmpty(t *testing.T) {
input := `[]`
args := new(GetBalanceArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
+}
+
+func TestGetBalanceArgsInvalid(t *testing.T) {
+ input := `6`
+ args := new(GetBalanceArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetBalanceArgsBlockInvalid(t *testing.T) {
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", false]`
+
+ args := new(GetBalanceArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetBalanceArgsAddressInvalid(t *testing.T) {
+ input := `[-9, "latest"]`
+
+ args := new(GetBalanceArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
}
func TestGetBlockByHashArgs(t *testing.T) {
@@ -100,17 +201,57 @@ func TestGetBlockByHashArgs(t *testing.T) {
}
}
-func TestGetBlockByHashEmpty(t *testing.T) {
+func TestGetBlockByHashArgsEmpty(t *testing.T) {
input := `[]`
args := new(GetBlockByHashArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetBlockByHashArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(GetBlockByHashArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
-func TestGetBlockByNumberArgs(t *testing.T) {
+func TestGetBlockByHashArgsHashInt(t *testing.T) {
+ input := `[8]`
+
+ args := new(GetBlockByHashArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetBlockByNumberArgsBlockNum(t *testing.T) {
+ input := `[436, false]`
+ expected := new(GetBlockByNumberArgs)
+ expected.BlockNumber = 436
+ expected.IncludeTxs = false
+
+ args := new(GetBlockByNumberArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err)
+ }
+
+ if args.BlockNumber != expected.BlockNumber {
+ t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber)
+ }
+
+ if args.IncludeTxs != expected.IncludeTxs {
+ t.Errorf("IncludeTxs should be %v but is %v", expected.IncludeTxs, args.IncludeTxs)
+ }
+}
+
+func TestGetBlockByNumberArgsBlockHex(t *testing.T) {
input := `["0x1b4", false]`
expected := new(GetBlockByNumberArgs)
expected.BlockNumber = 436
@@ -122,7 +263,7 @@ func TestGetBlockByNumberArgs(t *testing.T) {
}
if args.BlockNumber != expected.BlockNumber {
- t.Errorf("BlockHash should be %v but is %v", expected.BlockNumber, args.BlockNumber)
+ t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber)
}
if args.IncludeTxs != expected.IncludeTxs {
@@ -134,9 +275,28 @@ func TestGetBlockByNumberEmpty(t *testing.T) {
input := `[]`
args := new(GetBlockByNumberArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetBlockByNumberBool(t *testing.T) {
+ input := `[true, true]`
+
+ args := new(GetBlockByNumberArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+func TestGetBlockByNumberBlockObject(t *testing.T) {
+ input := `{}`
+
+ args := new(GetBlockByNumberArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
@@ -191,23 +351,150 @@ func TestNewTxArgs(t *testing.T) {
}
}
-func TestNewTxArgsBlockInt(t *testing.T) {
- input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155"}, 5]`
+func TestNewTxArgsInt(t *testing.T) {
+ input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+ "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
+ "gas": 100,
+ "gasPrice": 50,
+ "value": 8765456789,
+ "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"},
+ 5]`
expected := new(NewTxArgs)
- expected.From = "0xb60e8dd61c5d32be8058bb8eb970870f07233155"
- expected.BlockNumber = big.NewInt(5).Int64()
+ expected.Gas = big.NewInt(100)
+ expected.GasPrice = big.NewInt(50)
+ expected.Value = big.NewInt(8765456789)
+ expected.BlockNumber = int64(5)
args := new(NewTxArgs)
if err := json.Unmarshal([]byte(input), &args); err != nil {
t.Error(err)
}
- if expected.From != args.From {
- t.Errorf("From shoud be %#v but is %#v", expected.From, args.From)
+ if bytes.Compare(expected.Gas.Bytes(), args.Gas.Bytes()) != 0 {
+ t.Errorf("Gas shoud be %v but is %v", expected.Gas, args.Gas)
+ }
+
+ if bytes.Compare(expected.GasPrice.Bytes(), args.GasPrice.Bytes()) != 0 {
+ t.Errorf("GasPrice shoud be %v but is %v", expected.GasPrice, args.GasPrice)
+ }
+
+ if bytes.Compare(expected.Value.Bytes(), args.Value.Bytes()) != 0 {
+ t.Errorf("Value shoud be %v but is %v", expected.Value, args.Value)
}
if expected.BlockNumber != args.BlockNumber {
- t.Errorf("BlockNumber shoud be %#v but is %#v", expected.BlockNumber, args.BlockNumber)
+ t.Errorf("BlockNumber shoud be %v but is %v", expected.BlockNumber, args.BlockNumber)
+ }
+}
+
+func TestNewTxArgsBlockBool(t *testing.T) {
+ input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+ "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a000",
+ "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"},
+ false]`
+
+ args := new(NewTxArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestNewTxArgsGasInvalid(t *testing.T) {
+ input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+ "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
+ "gas": false,
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a000",
+ "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
+ }]`
+
+ args := new(NewTxArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestNewTxArgsGaspriceInvalid(t *testing.T) {
+ input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+ "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
+ "gas": "0x76c0",
+ "gasPrice": false,
+ "value": "0x9184e72a000",
+ "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
+ }]`
+
+ args := new(NewTxArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestNewTxArgsValueInvalid(t *testing.T) {
+ input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+ "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": false,
+ "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
+ }]`
+
+ args := new(NewTxArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestNewTxArgsGasMissing(t *testing.T) {
+ input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+ "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a000",
+ "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
+ }]`
+
+ args := new(NewTxArgs)
+ str := ExpectValidationError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestNewTxArgsBlockGaspriceMissing(t *testing.T) {
+ input := `[{
+ "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+ "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
+ "gas": "0x76c0",
+ "value": "0x9184e72a000",
+ "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
+ }]`
+
+ args := new(NewTxArgs)
+ str := ExpectValidationError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestNewTxArgsValueMissing(t *testing.T) {
+ input := `[{
+ "from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+ "to": "0xd46e8dd67c5d32be8058bb8eb970870f072445675",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
+ }]`
+
+ args := new(NewTxArgs)
+ str := ExpectValidationError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
@@ -215,37 +502,43 @@ func TestNewTxArgsEmpty(t *testing.T) {
input := `[]`
args := new(NewTxArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
-func TestNewTxArgsReqs(t *testing.T) {
- args := new(NewTxArgs)
- args.From = "0xb60e8dd61c5d32be8058bb8eb970870f07233155"
+func TestNewTxArgsInvalid(t *testing.T) {
+ input := `{}`
- err := args.requirements()
- switch err.(type) {
- case nil:
- break
- default:
- t.Errorf("Get %T", err)
+ args := new(NewTxArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
+func TestNewTxArgsNotStrings(t *testing.T) {
+ input := `[{"from":6}]`
-func TestNewTxArgsReqsFromBlank(t *testing.T) {
args := new(NewTxArgs)
- args.From = ""
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
- err := args.requirements()
+func TestNewTxArgsFromEmpty(t *testing.T) {
+ input := `[{"to": "0xb60e8dd61c5d32be8058bb8eb970870f07233155"}]`
+
+ args := new(NewTxArgs)
+ err := json.Unmarshal([]byte(input), &args)
switch err.(type) {
case nil:
t.Error("Expected error but didn't get one")
case *ValidationError:
break
default:
- t.Error("Wrong type of error")
+ t.Errorf("Expected *rpc.ValidationError, but got %T with message `%s`", err, err.Error())
}
}
@@ -260,10 +553,6 @@ func TestGetStorageArgs(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if expected.Address != args.Address {
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
}
@@ -273,13 +562,43 @@ func TestGetStorageArgs(t *testing.T) {
}
}
+func TestGetStorageInvalidArgs(t *testing.T) {
+ input := `{}`
+
+ args := new(GetStorageArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageInvalidBlockheight(t *testing.T) {
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", {}]`
+
+ args := new(GetStorageArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestGetStorageEmptyArgs(t *testing.T) {
input := `[]`
args := new(GetStorageArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageAddressInt(t *testing.T) {
+ input := `[32456785432456, "latest"]`
+
+ args := new(GetStorageArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
@@ -295,10 +614,6 @@ func TestGetStorageAtArgs(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if expected.Address != args.Address {
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
}
@@ -316,27 +631,63 @@ func TestGetStorageAtEmptyArgs(t *testing.T) {
input := `[]`
args := new(GetStorageAtArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageAtArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(GetStorageAtArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageAtArgsAddressNotString(t *testing.T) {
+ input := `[true, "0x0", "0x2"]`
+
+ args := new(GetStorageAtArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageAtArgsKeyNotString(t *testing.T) {
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", true, "0x2"]`
+
+ args := new(GetStorageAtArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageAtArgsValueNotString(t *testing.T) {
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "0x1", true]`
+
+ args := new(GetStorageAtArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
func TestGetTxCountArgs(t *testing.T) {
- input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]`
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "pending"]`
expected := new(GetTxCountArgs)
expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
- expected.BlockNumber = -1
+ expected.BlockNumber = -2
args := new(GetTxCountArgs)
if err := json.Unmarshal([]byte(input), &args); err != nil {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if expected.Address != args.Address {
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
}
@@ -350,9 +701,39 @@ func TestGetTxCountEmptyArgs(t *testing.T) {
input := `[]`
args := new(GetTxCountArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetTxCountEmptyArgsInvalid(t *testing.T) {
+ input := `false`
+
+ args := new(GetTxCountArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetTxCountAddressNotString(t *testing.T) {
+ input := `[false, "pending"]`
+
+ args := new(GetTxCountArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetTxCountBlockheightInvalid(t *testing.T) {
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", {}]`
+
+ args := new(GetTxCountArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
@@ -367,10 +748,6 @@ func TestGetDataArgs(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if expected.Address != args.Address {
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
}
@@ -380,13 +757,43 @@ func TestGetDataArgs(t *testing.T) {
}
}
-func TestGetDataEmptyArgs(t *testing.T) {
+func TestGetDataArgsEmpty(t *testing.T) {
input := `[]`
args := new(GetDataArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetDataArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(GetDataArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetDataArgsAddressNotString(t *testing.T) {
+ input := `[12, "latest"]`
+
+ args := new(GetDataArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetDataArgsBlocknumberNotString(t *testing.T) {
+ input := `["0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8", false]`
+
+ args := new(GetDataArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
@@ -397,14 +804,23 @@ func TestBlockFilterArgs(t *testing.T) {
"limit": "0x3",
"offset": "0x0",
"address": "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8",
- "topics": ["0x12341234"]}]`
+ "topics":
+ [
+ ["0xAA", "0xBB"],
+ ["0xCC", "0xDD"]
+ ]
+ }]`
+
expected := new(BlockFilterArgs)
expected.Earliest = 1
expected.Latest = 2
expected.Max = 3
expected.Skip = 0
- expected.Address = "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"
- // expected.Topics = []string{"0x12341234"}
+ expected.Address = []string{"0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"}
+ expected.Topics = [][]string{
+ []string{"0xAA", "0xBB"},
+ []string{"0xCC", "0xDD"},
+ }
args := new(BlockFilterArgs)
if err := json.Unmarshal([]byte(input), &args); err != nil {
@@ -427,13 +843,70 @@ func TestBlockFilterArgs(t *testing.T) {
t.Errorf("Skip shoud be %#v but is %#v", expected.Skip, args.Skip)
}
- if expected.Address != args.Address {
+ if expected.Address[0] != args.Address[0] {
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
}
- // if expected.Topics != args.Topics {
- // t.Errorf("Topic shoud be %#v but is %#v", expected.Topic, args.Topic)
- // }
+ if expected.Topics[0][0] != args.Topics[0][0] {
+ t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
+ }
+ if expected.Topics[0][1] != args.Topics[0][1] {
+ t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
+ }
+ if expected.Topics[1][0] != args.Topics[1][0] {
+ t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
+ }
+ if expected.Topics[1][1] != args.Topics[1][1] {
+ t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
+ }
+
+}
+
+func TestBlockFilterArgsDefaults(t *testing.T) {
+ input := `[{
+ "address": ["0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"],
+ "topics": ["0xAA","0xBB"]
+ }]`
+ expected := new(BlockFilterArgs)
+ expected.Earliest = -1
+ expected.Latest = -1
+ expected.Max = 100
+ expected.Skip = 0
+ expected.Address = []string{"0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"}
+ expected.Topics = [][]string{[]string{"0xAA"}, []string{"0xBB"}}
+
+ args := new(BlockFilterArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err)
+ }
+
+ if expected.Earliest != args.Earliest {
+ t.Errorf("Earliest shoud be %#v but is %#v", expected.Earliest, args.Earliest)
+ }
+
+ if expected.Latest != args.Latest {
+ t.Errorf("Latest shoud be %#v but is %#v", expected.Latest, args.Latest)
+ }
+
+ if expected.Max != args.Max {
+ t.Errorf("Max shoud be %#v but is %#v", expected.Max, args.Max)
+ }
+
+ if expected.Skip != args.Skip {
+ t.Errorf("Skip shoud be %#v but is %#v", expected.Skip, args.Skip)
+ }
+
+ if expected.Address[0] != args.Address[0] {
+ t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
+ }
+
+ if expected.Topics[0][0] != args.Topics[0][0] {
+ t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
+ }
+
+ if expected.Topics[1][0] != args.Topics[1][0] {
+ t.Errorf("Topics shoud be %#v but is %#v", expected.Topics, args.Topics)
+ }
}
func TestBlockFilterArgsWords(t *testing.T) {
@@ -459,21 +932,40 @@ func TestBlockFilterArgsWords(t *testing.T) {
}
}
-func TestBlockFilterArgsNums(t *testing.T) {
+func TestBlockFilterArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(BlockFilterArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockFilterArgsFromBool(t *testing.T) {
input := `[{
- "fromBlock": 2,
- "toBlock": 3
+ "fromBlock": true,
+ "toBlock": "pending"
}]`
args := new(BlockFilterArgs)
- err := json.Unmarshal([]byte(input), &args)
- switch err.(type) {
- case *DecodeParamError:
- break
- default:
- t.Errorf("Should have *DecodeParamError but instead have %T", err)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
+}
+
+func TestBlockFilterArgsToBool(t *testing.T) {
+ input := `[{
+ "fromBlock": "pending",
+ "toBlock": true
+ }]`
+ args := new(BlockFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
}
func TestBlockFilterArgsEmptyArgs(t *testing.T) {
@@ -486,6 +978,112 @@ func TestBlockFilterArgsEmptyArgs(t *testing.T) {
}
}
+func TestBlockFilterArgsLimitInvalid(t *testing.T) {
+ input := `[{"limit": false}]`
+
+ args := new(BlockFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockFilterArgsOffsetInvalid(t *testing.T) {
+ input := `[{"offset": true}]`
+
+ args := new(BlockFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockFilterArgsAddressInt(t *testing.T) {
+ input := `[{
+ "address": 1,
+ "topics": "0x12341234"}]`
+
+ args := new(BlockFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockFilterArgsAddressSliceInt(t *testing.T) {
+ input := `[{
+ "address": [1],
+ "topics": "0x12341234"}]`
+
+ args := new(BlockFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockFilterArgsTopicInt(t *testing.T) {
+ input := `[{
+ "address": ["0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8"],
+ "topics": 1}]`
+
+ args := new(BlockFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockFilterArgsTopicSliceInt(t *testing.T) {
+ input := `[{
+ "address": "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8",
+ "topics": [1]}]`
+
+ args := new(BlockFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockFilterArgsTopicSliceInt2(t *testing.T) {
+ input := `[{
+ "address": "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8",
+ "topics": ["0xAA", [1]]}]`
+
+ args := new(BlockFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockFilterArgsTopicComplex(t *testing.T) {
+ input := `[{
+ "address": "0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8",
+ "topics": ["0xAA", ["0xBB", "0xCC"]]
+ }]`
+
+ args := new(BlockFilterArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err)
+ fmt.Printf("%v\n", args)
+ return
+ }
+
+ if args.Topics[0][0] != "0xAA" {
+ t.Errorf("Topic should be %s but is %s", "0xAA", args.Topics[0][0])
+ }
+
+ if args.Topics[1][0] != "0xBB" {
+ t.Errorf("Topic should be %s but is %s", "0xBB", args.Topics[0][0])
+ }
+
+ if args.Topics[1][1] != "0xCC" {
+ t.Errorf("Topic should be %s but is %s", "0xCC", args.Topics[0][0])
+ }
+}
+
func TestDbArgs(t *testing.T) {
input := `["testDB","myKey","0xbeef"]`
expected := new(DbArgs)
@@ -515,6 +1113,84 @@ func TestDbArgs(t *testing.T) {
}
}
+func TestDbArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(DbArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(DbArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsDatabaseType(t *testing.T) {
+ input := `[true, "keyval", "valval"]`
+
+ args := new(DbArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsKeyType(t *testing.T) {
+ input := `["dbval", 3, "valval"]`
+
+ args := new(DbArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsValType(t *testing.T) {
+ input := `["dbval", "keyval", {}]`
+
+ args := new(DbArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsDatabaseEmpty(t *testing.T) {
+ input := `["", "keyval", "valval"]`
+
+ args := new(DbArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err.Error())
+ }
+
+ str := ExpectValidationError(args.requirements())
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsKeyEmpty(t *testing.T) {
+ input := `["dbval", "", "valval"]`
+
+ args := new(DbArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err.Error())
+ }
+
+ str := ExpectValidationError(args.requirements())
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestDbHexArgs(t *testing.T) {
input := `["testDB","myKey","0xbeef"]`
expected := new(DbHexArgs)
@@ -544,6 +1220,84 @@ func TestDbHexArgs(t *testing.T) {
}
}
+func TestDbHexArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(DbHexArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(DbHexArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsDatabaseType(t *testing.T) {
+ input := `[true, "keyval", "valval"]`
+
+ args := new(DbHexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsKeyType(t *testing.T) {
+ input := `["dbval", 3, "valval"]`
+
+ args := new(DbHexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsValType(t *testing.T) {
+ input := `["dbval", "keyval", {}]`
+
+ args := new(DbHexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsDatabaseEmpty(t *testing.T) {
+ input := `["", "keyval", "valval"]`
+
+ args := new(DbHexArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err.Error())
+ }
+
+ str := ExpectValidationError(args.requirements())
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsKeyEmpty(t *testing.T) {
+ input := `["dbval", "", "valval"]`
+
+ args := new(DbHexArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err.Error())
+ }
+
+ str := ExpectValidationError(args.requirements())
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestWhisperMessageArgs(t *testing.T) {
input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
"topics": ["0x68656c6c6f20776f726c64"],
@@ -556,7 +1310,7 @@ func TestWhisperMessageArgs(t *testing.T) {
expected.Payload = "0x68656c6c6f20776f726c64"
expected.Priority = 100
expected.Ttl = 100
- expected.Topics = []string{"0x68656c6c6f20776f726c64"}
+ // expected.Topics = []string{"0x68656c6c6f20776f726c64"}
args := new(WhisperMessageArgs)
if err := json.Unmarshal([]byte(input), &args); err != nil {
@@ -588,6 +1342,96 @@ func TestWhisperMessageArgs(t *testing.T) {
// }
}
+func TestWhisperMessageArgsInt(t *testing.T) {
+ input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
+ "topics": ["0x68656c6c6f20776f726c64"],
+ "payload":"0x68656c6c6f20776f726c64",
+ "ttl": 12,
+ "priority": 16}]`
+ expected := new(WhisperMessageArgs)
+ expected.From = "0xc931d93e97ab07fe42d923478ba2465f2"
+ expected.To = ""
+ expected.Payload = "0x68656c6c6f20776f726c64"
+ expected.Priority = 16
+ expected.Ttl = 12
+ // expected.Topics = []string{"0x68656c6c6f20776f726c64"}
+
+ args := new(WhisperMessageArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err)
+ }
+
+ if expected.From != args.From {
+ t.Errorf("From shoud be %#v but is %#v", expected.From, args.From)
+ }
+
+ if expected.To != args.To {
+ t.Errorf("To shoud be %#v but is %#v", expected.To, args.To)
+ }
+
+ if expected.Payload != args.Payload {
+ t.Errorf("Value shoud be %#v but is %#v", expected.Payload, args.Payload)
+ }
+
+ if expected.Ttl != args.Ttl {
+ t.Errorf("Ttl shoud be %v but is %v", expected.Ttl, args.Ttl)
+ }
+
+ if expected.Priority != args.Priority {
+ t.Errorf("Priority shoud be %v but is %v", expected.Priority, args.Priority)
+ }
+
+ // if expected.Topics != args.Topics {
+ // t.Errorf("Topic shoud be %#v but is %#v", expected.Topic, args.Topic)
+ // }
+}
+
+func TestWhisperMessageArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(WhisperMessageArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperMessageArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(WhisperMessageArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperMessageArgsTtlBool(t *testing.T) {
+ input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
+ "topics": ["0x68656c6c6f20776f726c64"],
+ "payload":"0x68656c6c6f20776f726c64",
+ "ttl": true,
+ "priority": "0x64"}]`
+ args := new(WhisperMessageArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperMessageArgsPriorityBool(t *testing.T) {
+ input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
+ "topics": ["0x68656c6c6f20776f726c64"],
+ "payload":"0x68656c6c6f20776f726c64",
+ "ttl": "0x12",
+ "priority": true}]`
+ args := new(WhisperMessageArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestFilterIdArgs(t *testing.T) {
input := `["0x7"]`
expected := new(FilterIdArgs)
@@ -603,10 +1447,39 @@ func TestFilterIdArgs(t *testing.T) {
}
}
-func TestWhsiperFilterArgs(t *testing.T) {
+func TestFilterIdArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(FilterIdArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestFilterIdArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(FilterIdArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestFilterIdArgsBool(t *testing.T) {
+ input := `[true]`
+
+ args := new(FilterIdArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestWhisperFilterArgs(t *testing.T) {
input := `[{"topics": ["0x68656c6c6f20776f726c64"], "to": "0x34ag445g3455b34"}]`
expected := new(WhisperFilterArgs)
- expected.From = ""
expected.To = "0x34ag445g3455b34"
expected.Topics = []string{"0x68656c6c6f20776f726c64"}
@@ -615,10 +1488,6 @@ func TestWhsiperFilterArgs(t *testing.T) {
t.Error(err)
}
- if expected.From != args.From {
- t.Errorf("From shoud be %#v but is %#v", expected.From, args.From)
- }
-
if expected.To != args.To {
t.Errorf("To shoud be %#v but is %#v", expected.To, args.To)
}
@@ -628,6 +1497,46 @@ func TestWhsiperFilterArgs(t *testing.T) {
// }
}
+func TestWhisperFilterArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(WhisperFilterArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperFilterArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(WhisperFilterArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperFilterArgsToBool(t *testing.T) {
+ input := `[{"topics": ["0x68656c6c6f20776f726c64"], "to": false}]`
+
+ args := new(WhisperFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperFilterArgsTopicInt(t *testing.T) {
+ input := `[{"topics": [6], "to": "0x34ag445g3455b34"}]`
+
+ args := new(WhisperFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestCompileArgs(t *testing.T) {
input := `["contract test { function multiply(uint a) returns(uint d) { return a * 7; } }"]`
expected := new(CompileArgs)
@@ -643,6 +1552,36 @@ func TestCompileArgs(t *testing.T) {
}
}
+func TestCompileArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(CompileArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestCompileArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(CompileArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestCompileArgsBool(t *testing.T) {
+ input := `[false]`
+
+ args := new(CompileArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestFilterStringArgs(t *testing.T) {
input := `["pending"]`
expected := new(FilterStringArgs)
@@ -653,10 +1592,6 @@ func TestFilterStringArgs(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if expected.Word != args.Word {
t.Errorf("Word shoud be %#v but is %#v", expected.Word, args.Word)
}
@@ -666,9 +1601,39 @@ func TestFilterStringEmptyArgs(t *testing.T) {
input := `[]`
args := new(FilterStringArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestFilterStringInvalidArgs(t *testing.T) {
+ input := `{}`
+
+ args := new(FilterStringArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestFilterStringWordInt(t *testing.T) {
+ input := `[7]`
+
+ args := new(FilterStringArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestFilterStringWordWrong(t *testing.T) {
+ input := `["foo"]`
+
+ args := new(FilterStringArgs)
+ str := ExpectValidationError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
}
}
@@ -687,6 +1652,36 @@ func TestWhisperIdentityArgs(t *testing.T) {
}
}
+func TestWhisperIdentityArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(WhisperIdentityArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestWhisperIdentityArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(WhisperIdentityArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestWhisperIdentityArgsInt(t *testing.T) {
+ input := `[4]`
+
+ args := new(WhisperIdentityArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
func TestBlockNumIndexArgs(t *testing.T) {
input := `["0x29a", "0x0"]`
expected := new(BlockNumIndexArgs)
@@ -707,6 +1702,46 @@ func TestBlockNumIndexArgs(t *testing.T) {
}
}
+func TestBlockNumIndexArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(BlockNumIndexArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockNumIndexArgsInvalid(t *testing.T) {
+ input := `"foo"`
+
+ args := new(BlockNumIndexArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockNumIndexArgsBlocknumInvalid(t *testing.T) {
+ input := `[{}, "0x1"]`
+
+ args := new(BlockNumIndexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockNumIndexArgsIndexInvalid(t *testing.T) {
+ input := `["0x29a", 1]`
+
+ args := new(BlockNumIndexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestHashIndexArgs(t *testing.T) {
input := `["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", "0x1"]`
expected := new(HashIndexArgs)
@@ -727,12 +1762,52 @@ func TestHashIndexArgs(t *testing.T) {
}
}
+func TestHashIndexArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(HashIndexArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestHashIndexArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(HashIndexArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestHashIndexArgsInvalidHash(t *testing.T) {
+ input := `[7, "0x1"]`
+
+ args := new(HashIndexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestHashIndexArgsInvalidIndex(t *testing.T) {
+ input := `["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", false]`
+
+ args := new(HashIndexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestSubmitWorkArgs(t *testing.T) {
input := `["0x0000000000000001", "0x1234567890abcdef1234567890abcdef", "0xD1GE5700000000000000000000000000"]`
expected := new(SubmitWorkArgs)
expected.Nonce = 1
- expected.Header = common.HexToHash("0x1234567890abcdef1234567890abcdef")
- expected.Digest = common.HexToHash("0xD1GE5700000000000000000000000000")
+ expected.Header = "0x1234567890abcdef1234567890abcdef"
+ expected.Digest = "0xD1GE5700000000000000000000000000"
args := new(SubmitWorkArgs)
if err := json.Unmarshal([]byte(input), &args); err != nil {
@@ -751,3 +1826,60 @@ func TestSubmitWorkArgs(t *testing.T) {
t.Errorf("Digest shoud be %#v but is %#v", expected.Digest, args.Digest)
}
}
+
+func TestSubmitWorkArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(SubmitWorkArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestSubmitWorkArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(SubmitWorkArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestSubmitWorkArgsNonceInt(t *testing.T) {
+ input := `[1, "0x1234567890abcdef1234567890abcdef", "0xD1GE5700000000000000000000000000"]`
+
+ args := new(SubmitWorkArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+func TestSubmitWorkArgsHeaderInt(t *testing.T) {
+ input := `["0x0000000000000001", 1, "0xD1GE5700000000000000000000000000"]`
+
+ args := new(SubmitWorkArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+func TestSubmitWorkArgsDigestInt(t *testing.T) {
+ input := `["0x0000000000000001", "0x1234567890abcdef1234567890abcdef", 1]`
+
+ args := new(SubmitWorkArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockHeightFromJsonInvalid(t *testing.T) {
+ var num int64
+ var msg json.RawMessage = []byte(`}{`)
+ str := ExpectDecodeParamError(blockHeightFromJson(msg, &num))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
diff --git a/rpc/messages.go b/rpc/messages.go
index 7f5ebab11..5c498234f 100644
--- a/rpc/messages.go
+++ b/rpc/messages.go
@@ -21,6 +21,22 @@ import (
"fmt"
)
+type InvalidTypeError struct {
+ method string
+ msg string
+}
+
+func (e *InvalidTypeError) Error() string {
+ return fmt.Sprintf("invalid type on field %s: %s", e.method, e.msg)
+}
+
+func NewInvalidTypeError(method, msg string) *InvalidTypeError {
+ return &InvalidTypeError{
+ method: method,
+ msg: msg,
+ }
+}
+
type InsufficientParamsError struct {
have int
want int
diff --git a/rpc/messages_test.go b/rpc/messages_test.go
index 5274c91e4..91f0152dc 100644
--- a/rpc/messages_test.go
+++ b/rpc/messages_test.go
@@ -4,6 +4,15 @@ import (
"testing"
)
+func TestInvalidTypeError(t *testing.T) {
+ err := NewInvalidTypeError("testField", "not string")
+ expected := "invalid type on field testField: not string"
+
+ if err.Error() != expected {
+ t.Error(err.Error())
+ }
+}
+
func TestInsufficientParamsError(t *testing.T) {
err := NewInsufficientParamsError(0, 1)
expected := "insufficient params, want 1 have 0"
diff --git a/xeth/xeth.go b/xeth/xeth.go
index 8ae1ee60d..7e1548964 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -110,6 +110,24 @@ func (self *XEth) stop() {
close(self.quit)
}
+func cAddress(a []string) []common.Address {
+ bslice := make([]common.Address, len(a))
+ for i, addr := range a {
+ bslice[i] = common.HexToAddress(addr)
+ }
+ return bslice
+}
+
+func cTopics(t [][]string) [][]common.Hash {
+ topics := make([][]common.Hash, len(t))
+ for i, iv := range t {
+ for j, jv := range iv {
+ topics[i][j] = common.HexToHash(jv)
+ }
+ }
+ return topics
+}
+
func (self *XEth) DefaultGas() *big.Int { return defaultGas }
func (self *XEth) DefaultGasPrice() *big.Int { return defaultGasPrice }
@@ -228,15 +246,15 @@ func (self *XEth) IsMining() bool {
}
func (self *XEth) EthVersion() string {
- return string(self.backend.EthVersion())
+ return fmt.Sprintf("%d", self.backend.EthVersion())
}
func (self *XEth) NetworkVersion() string {
- return string(self.backend.NetVersion())
+ return fmt.Sprintf("%d", self.backend.NetVersion())
}
func (self *XEth) WhisperVersion() string {
- return string(self.backend.ShhVersion())
+ return fmt.Sprintf("%d", self.backend.ShhVersion())
}
func (self *XEth) ClientVersion() string {
@@ -301,10 +319,15 @@ func (self *XEth) SecretToAddress(key string) string {
return common.ToHex(pair.Address())
}
-func (self *XEth) RegisterFilter(args *core.FilterOptions) int {
+func (self *XEth) RegisterFilter(earliest, latest int64, skip, max int, address []string, topics [][]string) int {
var id int
filter := core.NewFilter(self.backend)
- filter.SetOptions(args)
+ filter.SetEarliestBlock(earliest)
+ filter.SetLatestBlock(latest)
+ filter.SetSkip(skip)
+ filter.SetMax(max)
+ filter.SetAddress(cAddress(address))
+ filter.SetTopics(cTopics(topics))
filter.LogsCallback = func(logs state.Logs) {
self.logMut.Lock()
defer self.logMut.Unlock()
@@ -380,9 +403,14 @@ func (self *XEth) Logs(id int) state.Logs {
return nil
}
-func (self *XEth) AllLogs(args *core.FilterOptions) state.Logs {
+func (self *XEth) AllLogs(earliest, latest int64, skip, max int, address []string, topics [][]string) state.Logs {
filter := core.NewFilter(self.backend)
- filter.SetOptions(args)
+ filter.SetEarliestBlock(earliest)
+ filter.SetLatestBlock(latest)
+ filter.SetSkip(skip)
+ filter.SetMax(max)
+ filter.SetAddress(cAddress(address))
+ filter.SetTopics(cTopics(topics))
return filter.Find()
}
generated by cgit (git 2.34.1) at 2024-11-16 08:01:11 +0800