diff --git a/core/filter.go b/core/filter.go
index ba5d5e14e79fb60eed9febdb6cc5d15efe31cd2c..1dca5501dd693e78612b8d8e40643864e1b00468 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 f2915f658e4061c48fcaa6dec80ab40ec523873d..8803c28dd9ca12034073c6ac5f0aaafcc0f9281c 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 1928ec218d025c72d442a439ee01d6f4ab3146a7..a075f1a596b7bd9413af085c3bdbbfcb0511c105 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 5cbafd4b2fe9d5fd0237d8b223e4e768ba96d635..602631b677455e6b58cb848c778d933143c358f3 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 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 TestGetBlockByNumberArgs(t *testing.T) {
+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)
+	}
+}
+
+func TestNewTxArgsFromEmpty(t *testing.T) {
+	input := `[{"to": "0xb60e8dd61c5d32be8058bb8eb970870f07233155"}]`
 
-	err := args.requirements()
+	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,25 +631,61 @@ 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 TestGetTxCountArgs(t *testing.T) {
-	input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]`
-	expected := new(GetTxCountArgs)
-	expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
-	expected.BlockNumber = -1
+func TestGetStorageAtArgsInvalid(t *testing.T) {
+	input := `{}`
 
-	args := new(GetTxCountArgs)
-	if err := json.Unmarshal([]byte(input), &args); err != nil {
-		t.Error(err)
+	args := new(GetStorageAtArgs)
+	str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+	if len(str) > 0 {
+		t.Error(str)
 	}
+}
 
-	if err := args.requirements(); err != nil {
-		t.Error(err)
+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", "pending"]`
+	expected := new(GetTxCountArgs)
+	expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
+	expected.BlockNumber = -2
+
+	args := new(GetTxCountArgs)
+	if err := json.Unmarshal([]byte(input), &args); err != nil {
+		t.Error(err)
 	}
 
 	if 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 7f5ebab11b58ee68a18dc4cf64d431dc47336173..5c498234f9fb36c2adaebe39e8d0ff732286a897 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 5274c91e4249a4ff16d25b57d65f04c6425435ee..91f0152dc8227aa1081b716c7f3c49da2ca9e850 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 8ae1ee60de5045bbfc8281bea1571899b9b16154..7e1548964e6cf7880c705dcf6b4cb50063799116 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()
 }