Merge pull request #579 from tgerring/rpcargs

RPC Args
This commit is contained in:
Jeffrey Wilcke 2015-03-28 20:42:45 +01:00
commit b9ca5eef58
7 changed files with 1622 additions and 380 deletions

View File

@ -12,17 +12,6 @@ type AccountChange struct {
Address, StateAddress []byte Address, StateAddress []byte
} }
type FilterOptions struct {
Earliest int64
Latest int64
Address []common.Address
Topics [][]common.Hash
Skip int
Max int
}
// Filtering interface // Filtering interface
type Filter struct { type Filter struct {
eth Backend eth Backend
@ -44,18 +33,6 @@ func NewFilter(eth Backend) *Filter {
return &Filter{eth: eth} 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. // Set the earliest and latest block for filtering.
// -1 = latest block (i.e., the current block) // -1 = latest block (i.e., the current block)
// hash = particular hash from-to // hash = particular hash from-to

View File

@ -6,7 +6,6 @@ import (
"sync" "sync"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/xeth" "github.com/ethereum/go-ethereum/xeth"
) )
@ -82,10 +81,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err return err
} }
if err := args.requirements(); err != nil {
return err
}
v := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Balance() v := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Balance()
*reply = common.ToHex(v.Bytes()) *reply = common.ToHex(v.Bytes())
case "eth_getStorage", "eth_storageAt": case "eth_getStorage", "eth_storageAt":
@ -94,19 +89,12 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err return err
} }
if err := args.requirements(); err != nil {
return err
}
*reply = api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Storage() *reply = api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Storage()
case "eth_getStorageAt": case "eth_getStorageAt":
args := new(GetStorageAtArgs) args := new(GetStorageAtArgs)
if err := json.Unmarshal(req.Params, &args); err != nil { if err := json.Unmarshal(req.Params, &args); err != nil {
return err return err
} }
if err := args.requirements(); err != nil {
return err
}
state := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address) state := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address)
value := state.StorageString(args.Key) value := state.StorageString(args.Key)
@ -118,11 +106,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err return err
} }
err := args.requirements()
if err != nil {
return err
}
*reply = api.xethAtStateNum(args.BlockNumber).TxCountAt(args.Address) *reply = api.xethAtStateNum(args.BlockNumber).TxCountAt(args.Address)
case "eth_getBlockTransactionCountByHash": case "eth_getBlockTransactionCountByHash":
args := new(GetBlockByHashArgs) 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 { if err := json.Unmarshal(req.Params, &args); err != nil {
return err return err
} }
if err := args.requirements(); err != nil {
return err
}
*reply = api.xethAtStateNum(args.BlockNumber).CodeAt(args.Address) *reply = api.xethAtStateNum(args.BlockNumber).CodeAt(args.Address)
case "eth_sendTransaction", "eth_transact": case "eth_sendTransaction", "eth_transact":
args := new(NewTxArgs) args := new(NewTxArgs)
@ -173,10 +153,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return 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) v, err := api.xeth().Transact(args.From, args.To, args.Value.String(), args.Gas.String(), args.GasPrice.String(), args.Data)
if err != nil { if err != nil {
return err return err
@ -267,8 +243,8 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return NewValidationError("Index", "does not exist") return NewValidationError("Index", "does not exist")
} }
uhash := br.Uncles[args.Index].Hex() uhash := br.Uncles[args.Index]
uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash)) uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.Hex()))
*reply = uncle *reply = uncle
case "eth_getUncleByBlockNumberAndIndex": case "eth_getUncleByBlockNumberAndIndex":
@ -285,8 +261,8 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return NewValidationError("Index", "does not exist") return NewValidationError("Index", "does not exist")
} }
uhash := v.Uncles[args.Index].Hex() uhash := v.Uncles[args.Index]
uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash)) uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.Hex()))
*reply = uncle *reply = uncle
case "eth_getCompilers": case "eth_getCompilers":
@ -300,18 +276,13 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err return err
} }
opts := toFilterOptions(args) id := api.xeth().RegisterFilter(args.Earliest, args.Latest, args.Skip, args.Max, args.Address, args.Topics)
id := api.xeth().RegisterFilter(opts)
*reply = common.ToHex(big.NewInt(int64(id)).Bytes()) *reply = common.ToHex(big.NewInt(int64(id)).Bytes())
case "eth_newBlockFilter": case "eth_newBlockFilter":
args := new(FilterStringArgs) args := new(FilterStringArgs)
if err := json.Unmarshal(req.Params, &args); err != nil { if err := json.Unmarshal(req.Params, &args); err != nil {
return err return err
} }
if err := args.requirements(); err != nil {
return err
}
id := api.xeth().NewFilterString(args.Word) id := api.xeth().NewFilterString(args.Word)
*reply = common.ToHex(big.NewInt(int64(id)).Bytes()) *reply = common.ToHex(big.NewInt(int64(id)).Bytes())
case "eth_uninstallFilter": 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 { if err := json.Unmarshal(req.Params, &args); err != nil {
return err return err
} }
opts := toFilterOptions(args) *reply = NewLogsRes(api.xeth().AllLogs(args.Earliest, args.Latest, args.Skip, args.Max, args.Address, args.Topics))
*reply = NewLogsRes(api.xeth().AllLogs(opts))
case "eth_getWork": case "eth_getWork":
api.xeth().SetMining(true) api.xeth().SetMining(true)
*reply = api.xeth().RemoteMining().GetWork() *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 { if err := json.Unmarshal(req.Params, &args); err != nil {
return err 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": case "db_putString":
args := new(DbArgs) args := new(DbArgs)
if err := json.Unmarshal(req.Params, &args); err != nil { if err := json.Unmarshal(req.Params, &args); err != nil {
@ -433,7 +403,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err return err
} }
opts := new(xeth.Options) opts := new(xeth.Options)
opts.From = args.From // opts.From = args.From
opts.To = args.To opts.To = args.To
opts.Topics = args.Topics opts.Topics = args.Topics
id := api.xeth().NewWhisperFilter(opts) 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) rpclogger.DebugDetailf("Reply: %T %s", reply, reply)
return nil 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
*/

View File

@ -3,14 +3,27 @@ package rpc
import ( import (
"bytes" "bytes"
"encoding/json" "encoding/json"
"errors" // "errors"
"fmt" "fmt"
"math/big" "math/big"
"github.com/ethereum/go-ethereum/common" "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 // Parse as integer
num, ok := raw.(float64) num, ok := raw.(float64)
if ok { if ok {
@ -21,7 +34,7 @@ func blockHeight(raw interface{}, number *int64) (err error) {
// Parse as string/hexstring // Parse as string/hexstring
str, ok := raw.(string) str, ok := raw.(string)
if !ok { if !ok {
return NewDecodeParamError("BlockNumber is not a string") return NewInvalidTypeError("", "not a number or string")
} }
switch str { switch str {
@ -36,26 +49,55 @@ func blockHeight(raw interface{}, number *int64) (err error) {
return nil return nil
} }
func toNumber(v interface{}) (int64, error) { func numString(raw interface{}, number *int64) error {
var str string // Parse as integer
if v != nil { num, ok := raw.(float64)
var ok bool if ok {
str, ok = v.(string) *number = int64(num)
if !ok { return nil
return 0, errors.New("is not a string or undefined")
}
} else {
str = "latest"
} }
switch str { // Parse as string/hexstring
case "latest": str, ok := raw.(string)
return -1, nil if !ok {
default: return NewInvalidTypeError("", "not a number or string")
return int64(common.Big(v.(string)).Int64()), nil
} }
*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 { type GetBlockByHashArgs struct {
BlockHash string BlockHash string
IncludeTxs bool IncludeTxs bool
@ -74,7 +116,7 @@ func (args *GetBlockByHashArgs) UnmarshalJSON(b []byte) (err error) {
argstr, ok := obj[0].(string) argstr, ok := obj[0].(string)
if !ok { if !ok {
return NewDecodeParamError("BlockHash not a string") return NewInvalidTypeError("blockHash", "not a string")
} }
args.BlockHash = argstr args.BlockHash = argstr
@ -103,8 +145,10 @@ func (args *GetBlockByNumberArgs) UnmarshalJSON(b []byte) (err error) {
if v, ok := obj[0].(float64); ok { if v, ok := obj[0].(float64); ok {
args.BlockNumber = int64(v) args.BlockNumber = int64(v)
} else if v, ok := obj[0].(string); ok {
args.BlockNumber = common.Big(v).Int64()
} else { } else {
args.BlockNumber = common.Big(obj[0].(string)).Int64() return NewInvalidTypeError("blockNumber", "not a number or string")
} }
if len(obj) > 1 { if len(obj) > 1 {
@ -127,7 +171,14 @@ type NewTxArgs struct {
func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) { func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
var obj []json.RawMessage 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 // Decode byte slice to array of RawMessages
if err := json.Unmarshal(b, &obj); err != nil { if err := json.Unmarshal(b, &obj); err != nil {
@ -144,22 +195,45 @@ func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
return NewDecodeParamError(err.Error()) return NewDecodeParamError(err.Error())
} }
// var ok bool if len(ext.From) == 0 {
return NewValidationError("from", "is required")
}
args.From = ext.From args.From = ext.From
args.To = ext.To 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 args.Data = ext.Data
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 ext.Gas == nil {
return NewValidationError("gas", "is required")
} else {
if err := numString(ext.Gas, &num); err != nil {
return err
}
}
args.Gas = big.NewInt(num)
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)
// Check for optional BlockNumber param // Check for optional BlockNumber param
if len(obj) > 1 { if len(obj) > 1 {
var raw interface{} if err := blockHeightFromJson(obj[1], &args.BlockNumber); err != nil {
if err = json.Unmarshal(obj[1], &raw); err != nil {
return NewDecodeParamError(err.Error())
}
if err := blockHeight(raw, &args.BlockNumber); err != nil {
return err return err
} }
} }
@ -167,13 +241,6 @@ func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
return nil return nil
} }
func (args *NewTxArgs) requirements() error {
if len(args.From) == 0 {
return NewValidationError("From", "Is required")
}
return nil
}
type GetStorageArgs struct { type GetStorageArgs struct {
Address string Address string
BlockNumber int64 BlockNumber int64
@ -191,7 +258,7 @@ func (args *GetStorageArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string) addstr, ok := obj[0].(string)
if !ok { if !ok {
return NewDecodeParamError("Address is not a string") return NewInvalidTypeError("address", "not a string")
} }
args.Address = addstr args.Address = addstr
@ -204,13 +271,6 @@ func (args *GetStorageArgs) UnmarshalJSON(b []byte) (err error) {
return nil return nil
} }
func (args *GetStorageArgs) requirements() error {
if len(args.Address) == 0 {
return NewValidationError("Address", "cannot be blank")
}
return nil
}
type GetStorageAtArgs struct { type GetStorageAtArgs struct {
Address string Address string
Key string Key string
@ -229,13 +289,13 @@ func (args *GetStorageAtArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string) addstr, ok := obj[0].(string)
if !ok { if !ok {
return NewDecodeParamError("Address is not a string") return NewInvalidTypeError("address", "not a string")
} }
args.Address = addstr args.Address = addstr
keystr, ok := obj[1].(string) keystr, ok := obj[1].(string)
if !ok { if !ok {
return NewDecodeParamError("Key is not a string") return NewInvalidTypeError("key", "not a string")
} }
args.Key = keystr args.Key = keystr
@ -248,17 +308,6 @@ func (args *GetStorageAtArgs) UnmarshalJSON(b []byte) (err error) {
return nil 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 { type GetTxCountArgs struct {
Address string Address string
BlockNumber int64 BlockNumber int64
@ -276,7 +325,7 @@ func (args *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string) addstr, ok := obj[0].(string)
if !ok { if !ok {
return NewDecodeParamError("Address is not a string") return NewInvalidTypeError("address", "not a string")
} }
args.Address = addstr args.Address = addstr
@ -289,13 +338,6 @@ func (args *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
return nil return nil
} }
func (args *GetTxCountArgs) requirements() error {
if len(args.Address) == 0 {
return NewValidationError("Address", "cannot be blank")
}
return nil
}
type GetBalanceArgs struct { type GetBalanceArgs struct {
Address string Address string
BlockNumber int64 BlockNumber int64
@ -313,7 +355,7 @@ func (args *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string) addstr, ok := obj[0].(string)
if !ok { if !ok {
return NewDecodeParamError("Address is not a string") return NewInvalidTypeError("address", "not a string")
} }
args.Address = addstr args.Address = addstr
@ -326,13 +368,6 @@ func (args *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
return nil return nil
} }
func (args *GetBalanceArgs) requirements() error {
if len(args.Address) == 0 {
return NewValidationError("Address", "cannot be blank")
}
return nil
}
type GetDataArgs struct { type GetDataArgs struct {
Address string Address string
BlockNumber int64 BlockNumber int64
@ -350,7 +385,7 @@ func (args *GetDataArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string) addstr, ok := obj[0].(string)
if !ok { if !ok {
return NewDecodeParamError("Address is not a string") return NewInvalidTypeError("address", "not a string")
} }
args.Address = addstr args.Address = addstr
@ -363,13 +398,6 @@ func (args *GetDataArgs) UnmarshalJSON(b []byte) (err error) {
return nil return nil
} }
func (args *GetDataArgs) requirements() error {
if len(args.Address) == 0 {
return NewValidationError("Address", "cannot be blank")
}
return nil
}
type BlockNumIndexArgs struct { type BlockNumIndexArgs struct {
BlockNumber int64 BlockNumber int64
Index int64 Index int64
@ -386,16 +414,14 @@ func (args *BlockNumIndexArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1) return NewInsufficientParamsError(len(obj), 1)
} }
arg0, ok := obj[0].(string) if err := blockHeight(obj[0], &args.BlockNumber); err != nil {
if !ok { return err
return NewDecodeParamError("BlockNumber is not string")
} }
args.BlockNumber = common.Big(arg0).Int64()
if len(obj) > 1 { if len(obj) > 1 {
arg1, ok := obj[1].(string) arg1, ok := obj[1].(string)
if !ok { if !ok {
return NewDecodeParamError("Index not a string") return NewInvalidTypeError("index", "not a string")
} }
args.Index = common.Big(arg1).Int64() args.Index = common.Big(arg1).Int64()
} }
@ -421,14 +447,14 @@ func (args *HashIndexArgs) UnmarshalJSON(b []byte) (err error) {
arg0, ok := obj[0].(string) arg0, ok := obj[0].(string)
if !ok { if !ok {
return NewDecodeParamError("Hash not a string") return NewInvalidTypeError("hash", "not a string")
} }
args.Hash = arg0 args.Hash = arg0
if len(obj) > 1 { if len(obj) > 1 {
arg1, ok := obj[1].(string) arg1, ok := obj[1].(string)
if !ok { if !ok {
return NewDecodeParamError("Index not a string") return NewInvalidTypeError("index", "not a string")
} }
args.Index = common.Big(arg1).Int64() args.Index = common.Big(arg1).Int64()
} }
@ -450,28 +476,32 @@ func (args *Sha3Args) UnmarshalJSON(b []byte) (err error) {
if len(obj) < 1 { if len(obj) < 1 {
return NewInsufficientParamsError(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 return nil
} }
type BlockFilterArgs struct { type BlockFilterArgs struct {
Earliest int64 Earliest int64
Latest int64 Latest int64
Address interface{} Address []string
Topics []interface{} Topics [][]string
Skip int Skip int
Max int Max int
} }
func (args *BlockFilterArgs) UnmarshalJSON(b []byte) (err error) { func (args *BlockFilterArgs) UnmarshalJSON(b []byte) (err error) {
var obj []struct { var obj []struct {
FromBlock interface{} `json:"fromBlock"` FromBlock interface{} `json:"fromBlock"`
ToBlock interface{} `json:"toBlock"` ToBlock interface{} `json:"toBlock"`
Limit string `json:"limit"` Limit interface{} `json:"limit"`
Offset string `json:"offset"` Offset interface{} `json:"offset"`
Address string `json:"address"` Address interface{} `json:"address"`
Topics []interface{} `json:"topics"` Topics interface{} `json:"topics"`
} }
if err = json.Unmarshal(b, &obj); err != nil { 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) return NewInsufficientParamsError(len(obj), 1)
} }
args.Earliest, err = toNumber(obj[0].ToBlock) // args.Earliest, err = toNumber(obj[0].ToBlock)
if err != nil { // if err != nil {
return NewDecodeParamError(fmt.Sprintf("FromBlock %v", err)) // 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 -2 or other "silly" number, use latest
if err != nil { if num < 0 {
return NewDecodeParamError(fmt.Sprintf("ToBlock %v", err)) args.Earliest = -1 //latest block
} else {
args.Earliest = num
} }
args.Max = int(common.Big(obj[0].Limit).Int64()) // if blank than latest
args.Skip = int(common.Big(obj[0].Offset).Int64()) if obj[0].ToBlock == nil {
args.Address = obj[0].Address num = -1
args.Topics = obj[0].Topics } 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 return nil
} }
@ -519,19 +643,19 @@ func (args *DbArgs) UnmarshalJSON(b []byte) (err error) {
var ok bool var ok bool
if objstr, ok = obj[0].(string); !ok { if objstr, ok = obj[0].(string); !ok {
return NewDecodeParamError("Database is not a string") return NewInvalidTypeError("database", "not a string")
} }
args.Database = objstr args.Database = objstr
if objstr, ok = obj[1].(string); !ok { if objstr, ok = obj[1].(string); !ok {
return NewDecodeParamError("Key is not a string") return NewInvalidTypeError("key", "not a string")
} }
args.Key = objstr args.Key = objstr
if len(obj) > 2 { if len(obj) > 2 {
objstr, ok = obj[2].(string) objstr, ok = obj[2].(string)
if !ok { if !ok {
return NewDecodeParamError("Value is not a string") return NewInvalidTypeError("value", "not a string")
} }
args.Value = []byte(objstr) args.Value = []byte(objstr)
@ -570,19 +694,19 @@ func (args *DbHexArgs) UnmarshalJSON(b []byte) (err error) {
var ok bool var ok bool
if objstr, ok = obj[0].(string); !ok { if objstr, ok = obj[0].(string); !ok {
return NewDecodeParamError("Database is not a string") return NewInvalidTypeError("database", "not a string")
} }
args.Database = objstr args.Database = objstr
if objstr, ok = obj[1].(string); !ok { if objstr, ok = obj[1].(string); !ok {
return NewDecodeParamError("Key is not a string") return NewInvalidTypeError("key", "not a string")
} }
args.Key = objstr args.Key = objstr
if len(obj) > 2 { if len(obj) > 2 {
objstr, ok = obj[2].(string) objstr, ok = obj[2].(string)
if !ok { if !ok {
return NewDecodeParamError("Value is not a string") return NewInvalidTypeError("value", "not a string")
} }
args.Value = common.FromHex(objstr) args.Value = common.FromHex(objstr)
@ -616,8 +740,8 @@ func (args *WhisperMessageArgs) UnmarshalJSON(b []byte) (err error) {
To string To string
From string From string
Topics []string Topics []string
Priority string Priority interface{}
Ttl string Ttl interface{}
} }
if err = json.Unmarshal(b, &obj); err != nil { 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.To = obj[0].To
args.From = obj[0].From args.From = obj[0].From
args.Topics = obj[0].Topics 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 return nil
} }
@ -643,14 +776,18 @@ type CompileArgs struct {
func (args *CompileArgs) UnmarshalJSON(b []byte) (err error) { func (args *CompileArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{} var obj []interface{}
r := bytes.NewReader(b) if err := json.Unmarshal(b, &obj); err != nil {
if err := json.NewDecoder(r).Decode(&obj); err != nil {
return NewDecodeParamError(err.Error()) return NewDecodeParamError(err.Error())
} }
if len(obj) > 0 { if len(obj) < 1 {
args.Source = obj[0].(string) return NewInsufficientParamsError(len(obj), 1)
} }
argstr, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("arg0", "is not a string")
}
args.Source = argstr
return nil return nil
} }
@ -673,20 +810,15 @@ func (args *FilterStringArgs) UnmarshalJSON(b []byte) (err error) {
var argstr string var argstr string
argstr, ok := obj[0].(string) argstr, ok := obj[0].(string)
if !ok { if !ok {
return NewDecodeParamError("Filter is not a string") return NewInvalidTypeError("filter", "not a string")
} }
args.Word = argstr switch argstr {
return nil
}
func (args *FilterStringArgs) requirements() error {
switch args.Word {
case "latest", "pending": case "latest", "pending":
break break
default: default:
return NewValidationError("Word", "Must be `latest` or `pending`") return NewValidationError("Word", "Must be `latest` or `pending`")
} }
args.Word = argstr
return nil return nil
} }
@ -695,9 +827,8 @@ type FilterIdArgs struct {
} }
func (args *FilterIdArgs) UnmarshalJSON(b []byte) (err error) { func (args *FilterIdArgs) UnmarshalJSON(b []byte) (err error) {
var obj []string var obj []interface{}
r := bytes.NewReader(b) if err := json.Unmarshal(b, &obj); err != nil {
if err := json.NewDecoder(r).Decode(&obj); err != nil {
return NewDecodeParamError(err.Error()) return NewDecodeParamError(err.Error())
} }
@ -705,7 +836,11 @@ func (args *FilterIdArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1) 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 return nil
} }
@ -715,9 +850,8 @@ type WhisperIdentityArgs struct {
} }
func (args *WhisperIdentityArgs) UnmarshalJSON(b []byte) (err error) { func (args *WhisperIdentityArgs) UnmarshalJSON(b []byte) (err error) {
var obj []string var obj []interface{}
r := bytes.NewReader(b) if err := json.Unmarshal(b, &obj); err != nil {
if err := json.NewDecoder(r).Decode(&obj); err != nil {
return NewDecodeParamError(err.Error()) return NewDecodeParamError(err.Error())
} }
@ -725,7 +859,14 @@ func (args *WhisperIdentityArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1) 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 return nil
} }
@ -738,9 +879,8 @@ type WhisperFilterArgs struct {
func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) { func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
var obj []struct { var obj []struct {
To string To interface{}
From string Topics []interface{}
Topics []string
} }
if err = json.Unmarshal(b, &obj); err != nil { 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) return NewInsufficientParamsError(len(obj), 1)
} }
args.To = obj[0].To var argstr string
args.From = obj[0].From argstr, ok := obj[0].To.(string)
args.Topics = obj[0].Topics 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 return nil
} }
type SubmitWorkArgs struct { type SubmitWorkArgs struct {
Nonce uint64 Nonce uint64
Header common.Hash Header string
Digest common.Hash Digest string
} }
func (args *SubmitWorkArgs) UnmarshalJSON(b []byte) (err error) { func (args *SubmitWorkArgs) UnmarshalJSON(b []byte) (err error) {
@ -777,21 +930,21 @@ func (args *SubmitWorkArgs) UnmarshalJSON(b []byte) (err error) {
var objstr string var objstr string
var ok bool var ok bool
if objstr, ok = obj[0].(string); !ok { 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() args.Nonce = common.String2Big(objstr).Uint64()
if objstr, ok = obj[1].(string); !ok { 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 { 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 return nil
} }

File diff suppressed because it is too large Load Diff

View File

@ -21,6 +21,22 @@ import (
"fmt" "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 { type InsufficientParamsError struct {
have int have int
want int want int

View File

@ -4,6 +4,15 @@ import (
"testing" "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) { func TestInsufficientParamsError(t *testing.T) {
err := NewInsufficientParamsError(0, 1) err := NewInsufficientParamsError(0, 1)
expected := "insufficient params, want 1 have 0" expected := "insufficient params, want 1 have 0"

View File

@ -110,6 +110,24 @@ func (self *XEth) stop() {
close(self.quit) 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) DefaultGas() *big.Int { return defaultGas }
func (self *XEth) DefaultGasPrice() *big.Int { return defaultGasPrice } func (self *XEth) DefaultGasPrice() *big.Int { return defaultGasPrice }
@ -228,15 +246,15 @@ func (self *XEth) IsMining() bool {
} }
func (self *XEth) EthVersion() string { func (self *XEth) EthVersion() string {
return string(self.backend.EthVersion()) return fmt.Sprintf("%d", self.backend.EthVersion())
} }
func (self *XEth) NetworkVersion() string { func (self *XEth) NetworkVersion() string {
return string(self.backend.NetVersion()) return fmt.Sprintf("%d", self.backend.NetVersion())
} }
func (self *XEth) WhisperVersion() string { func (self *XEth) WhisperVersion() string {
return string(self.backend.ShhVersion()) return fmt.Sprintf("%d", self.backend.ShhVersion())
} }
func (self *XEth) ClientVersion() string { func (self *XEth) ClientVersion() string {
@ -301,10 +319,15 @@ func (self *XEth) SecretToAddress(key string) string {
return common.ToHex(pair.Address()) 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 var id int
filter := core.NewFilter(self.backend) 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) { filter.LogsCallback = func(logs state.Logs) {
self.logMut.Lock() self.logMut.Lock()
defer self.logMut.Unlock() defer self.logMut.Unlock()
@ -380,9 +403,14 @@ func (self *XEth) Logs(id int) state.Logs {
return nil 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 := 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() return filter.Find()
} }