plugeth/rpc/args.go

951 lines
19 KiB
Go
Raw Normal View History

2015-01-20 19:57:51 +00:00
package rpc
2015-03-04 14:22:59 +00:00
import (
2015-03-06 03:37:45 +00:00
"bytes"
2015-03-04 14:22:59 +00:00
"encoding/json"
// "errors"
2015-03-27 14:54:54 +00:00
"fmt"
2015-03-04 14:22:59 +00:00
"math/big"
2015-03-16 10:27:38 +00:00
"github.com/ethereum/go-ethereum/common"
2015-03-04 14:22:59 +00:00
)
2015-01-20 19:57:51 +00:00
2015-03-27 14:54:54 +00:00
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 {
2015-03-18 19:42:57 +00:00
// Parse as integer
2015-03-18 19:48:34 +00:00
num, ok := raw.(float64)
2015-03-18 19:42:57 +00:00
if ok {
2015-03-18 19:48:34 +00:00
*number = int64(num)
2015-03-18 19:42:57 +00:00
return nil
}
// Parse as string/hexstring
str, ok := raw.(string)
if !ok {
2015-03-26 21:58:12 +00:00
return NewInvalidTypeError("", "not a number or string")
2015-03-10 12:40:49 +00:00
}
switch str {
case "latest":
*number = -1
case "pending":
*number = -2
default:
2015-03-16 10:27:38 +00:00
*number = common.String2Big(str).Int64()
2015-03-10 12:40:49 +00:00
}
2015-03-18 19:42:57 +00:00
2015-03-10 12:40:49 +00:00
return nil
}
func numString(raw interface{}, number *int64) error {
// Parse as integer
num, ok := raw.(float64)
if ok {
*number = int64(num)
return 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
// }
// }
2015-03-26 21:58:12 +00:00
// 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
// }
2015-03-06 03:37:45 +00:00
type GetBlockByHashArgs struct {
2015-03-26 21:14:31 +00:00
BlockHash string
2015-03-20 03:20:54 +00:00
IncludeTxs bool
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
func (args *GetBlockByHashArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
r := bytes.NewReader(b)
if err := json.NewDecoder(r).Decode(&obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-01-20 19:57:51 +00:00
}
2015-03-11 15:27:24 +00:00
argstr, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("blockHash", "not a string")
2015-03-11 15:27:24 +00:00
}
2015-03-26 21:14:31 +00:00
args.BlockHash = argstr
2015-03-06 03:37:45 +00:00
if len(obj) > 1 {
2015-03-20 03:20:54 +00:00
args.IncludeTxs = obj[1].(bool)
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
return nil
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
type GetBlockByNumberArgs struct {
2015-03-20 03:20:54 +00:00
BlockNumber int64
IncludeTxs bool
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
func (args *GetBlockByNumberArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
r := bytes.NewReader(b)
if err := json.NewDecoder(r).Decode(&obj); err != nil {
return NewDecodeParamError(err.Error())
}
2015-03-06 03:37:45 +00:00
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-06 03:37:45 +00:00
}
if v, ok := obj[0].(float64); ok {
args.BlockNumber = int64(v)
2015-03-26 10:07:14 +00:00
} else if v, ok := obj[0].(string); ok {
args.BlockNumber = common.Big(v).Int64()
} else {
return NewInvalidTypeError("blockNumber", "not a number or string")
}
2015-03-06 03:37:45 +00:00
if len(obj) > 1 {
2015-03-20 03:20:54 +00:00
args.IncludeTxs = obj[1].(bool)
}
2015-03-06 03:37:45 +00:00
return nil
}
2015-03-06 03:37:45 +00:00
type NewTxArgs struct {
2015-03-26 21:35:42 +00:00
From string
To string
2015-03-06 03:37:45 +00:00
Value *big.Int
Gas *big.Int
GasPrice *big.Int
Data string
2015-03-10 12:40:49 +00:00
BlockNumber int64
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-18 19:42:57 +00:00
var obj []json.RawMessage
var ext struct {
From string
To string
Value interface{}
Gas interface{}
GasPrice interface{}
Data string
}
2015-03-18 19:42:57 +00:00
// Decode byte slice to array of RawMessages
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
2015-03-18 19:42:57 +00:00
// Check for sufficient params
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
// Decode 0th RawMessage to temporary struct
if err := json.Unmarshal(obj[0], &ext); err != nil {
return NewDecodeParamError(err.Error())
}
2015-03-26 09:34:21 +00:00
if len(ext.From) == 0 {
return NewValidationError("from", "is required")
}
2015-03-26 21:35:42 +00:00
args.From = ext.From
args.To = ext.To
2015-03-18 19:42:57 +00:00
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)
2015-03-18 19:42:57 +00:00
// Check for optional BlockNumber param
if len(obj) > 1 {
2015-03-26 10:59:35 +00:00
if err := blockHeightFromJson(obj[1], &args.BlockNumber); err != nil {
2015-03-18 19:42:57 +00:00
return err
}
}
2015-03-06 03:37:45 +00:00
2015-01-20 19:57:51 +00:00
return nil
}
type GetStorageArgs struct {
2015-03-26 21:35:42 +00:00
Address string
2015-03-06 15:54:08 +00:00
BlockNumber int64
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
func (args *GetStorageArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-18 19:42:57 +00:00
var obj []interface{}
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
2015-03-06 03:37:45 +00:00
2015-03-18 19:42:57 +00:00
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
addstr, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("address", "not a string")
2015-03-18 19:42:57 +00:00
}
2015-03-26 21:35:42 +00:00
args.Address = addstr
2015-03-18 19:42:57 +00:00
if len(obj) > 1 {
2015-03-23 15:34:50 +00:00
if err := blockHeight(obj[1], &args.BlockNumber); err != nil {
2015-03-18 19:42:57 +00:00
return err
}
}
2015-03-06 03:37:45 +00:00
return nil
}
2015-03-05 18:26:21 +00:00
type GetStorageAtArgs struct {
2015-03-26 21:35:42 +00:00
Address string
Key string
2015-03-06 15:54:08 +00:00
BlockNumber int64
}
2015-03-06 03:37:45 +00:00
func (args *GetStorageAtArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-18 19:42:57 +00:00
var obj []interface{}
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
2015-03-18 19:42:57 +00:00
2015-03-06 03:37:45 +00:00
if len(obj) < 2 {
return NewInsufficientParamsError(len(obj), 2)
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
2015-03-18 19:42:57 +00:00
addstr, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("address", "not a string")
2015-03-18 19:42:57 +00:00
}
2015-03-26 21:35:42 +00:00
args.Address = addstr
2015-03-18 19:42:57 +00:00
keystr, ok := obj[1].(string)
if !ok {
return NewInvalidTypeError("key", "not a string")
2015-03-18 19:42:57 +00:00
}
2015-03-26 21:35:42 +00:00
args.Key = keystr
2015-03-18 19:42:57 +00:00
if len(obj) > 2 {
2015-03-23 15:34:50 +00:00
if err := blockHeight(obj[2], &args.BlockNumber); err != nil {
2015-03-18 19:42:57 +00:00
return err
}
}
2015-03-06 03:37:45 +00:00
return nil
2015-01-20 19:57:51 +00:00
}
type GetTxCountArgs struct {
2015-03-26 21:35:42 +00:00
Address string
2015-03-06 15:54:08 +00:00
BlockNumber int64
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
func (args *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-18 19:42:57 +00:00
var obj []interface{}
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
2015-03-18 19:42:57 +00:00
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
addstr, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("address", "not a string")
2015-03-18 19:42:57 +00:00
}
2015-03-26 21:35:42 +00:00
args.Address = addstr
2015-03-18 19:42:57 +00:00
if len(obj) > 1 {
2015-03-23 15:34:50 +00:00
if err := blockHeight(obj[1], &args.BlockNumber); err != nil {
2015-03-18 19:42:57 +00:00
return err
}
}
2015-03-06 03:37:45 +00:00
return nil
2015-01-20 19:57:51 +00:00
}
type GetBalanceArgs struct {
2015-03-26 21:35:42 +00:00
Address string
2015-03-06 15:54:08 +00:00
BlockNumber int64
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
func (args *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-12 13:42:31 +00:00
var obj []interface{}
2015-03-18 19:42:57 +00:00
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-12 13:42:31 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-12 13:42:31 +00:00
}
addstr, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("address", "not a string")
2015-03-06 03:37:45 +00:00
}
2015-03-26 21:35:42 +00:00
args.Address = addstr
2015-03-12 13:42:31 +00:00
if len(obj) > 1 {
2015-03-23 15:34:50 +00:00
if err := blockHeight(obj[1], &args.BlockNumber); err != nil {
2015-03-18 19:42:57 +00:00
return err
2015-03-12 13:42:31 +00:00
}
}
2015-03-06 03:37:45 +00:00
return nil
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
type GetDataArgs struct {
2015-03-26 21:35:42 +00:00
Address string
2015-03-06 15:54:08 +00:00
BlockNumber int64
2015-01-20 19:57:51 +00:00
}
2015-03-06 03:37:45 +00:00
func (args *GetDataArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-18 19:42:57 +00:00
var obj []interface{}
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
2015-03-18 19:42:57 +00:00
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
addstr, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("address", "not a string")
2015-03-18 19:42:57 +00:00
}
2015-03-26 21:35:42 +00:00
args.Address = addstr
2015-03-18 19:42:57 +00:00
if len(obj) > 1 {
2015-03-23 15:34:50 +00:00
if err := blockHeight(obj[1], &args.BlockNumber); err != nil {
2015-03-18 19:42:57 +00:00
return err
}
}
2015-03-06 03:37:45 +00:00
return nil
2015-01-20 19:57:51 +00:00
}
2015-03-11 03:25:07 +00:00
type BlockNumIndexArgs struct {
BlockNumber int64
2015-03-11 15:25:15 +00:00
Index int64
2015-03-11 03:25:07 +00:00
}
2015-03-11 20:26:28 +00:00
func (args *BlockNumIndexArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
r := bytes.NewReader(b)
if err := json.NewDecoder(r).Decode(&obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-11 20:26:28 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-11 20:26:28 +00:00
}
2015-03-26 12:57:41 +00:00
if err := blockHeight(obj[0], &args.BlockNumber); err != nil {
return err
2015-03-11 20:26:28 +00:00
}
if len(obj) > 1 {
arg1, ok := obj[1].(string)
if !ok {
return NewInvalidTypeError("index", "not a string")
2015-03-11 20:26:28 +00:00
}
2015-03-16 10:27:38 +00:00
args.Index = common.Big(arg1).Int64()
2015-03-11 20:26:28 +00:00
}
return nil
}
2015-03-11 03:25:07 +00:00
type HashIndexArgs struct {
2015-03-26 21:14:31 +00:00
Hash string
Index int64
2015-03-11 03:25:07 +00:00
}
2015-03-11 20:26:28 +00:00
func (args *HashIndexArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
r := bytes.NewReader(b)
if err := json.NewDecoder(r).Decode(&obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-11 20:26:28 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-11 20:26:28 +00:00
}
arg0, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("hash", "not a string")
2015-03-11 20:26:28 +00:00
}
2015-03-26 21:14:31 +00:00
args.Hash = arg0
2015-03-11 20:26:28 +00:00
if len(obj) > 1 {
arg1, ok := obj[1].(string)
if !ok {
return NewInvalidTypeError("index", "not a string")
2015-03-11 20:26:28 +00:00
}
2015-03-16 10:27:38 +00:00
args.Index = common.Big(arg1).Int64()
2015-03-11 20:26:28 +00:00
}
return nil
}
type Sha3Args struct {
Data string
}
2015-03-06 03:37:45 +00:00
func (args *Sha3Args) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
r := bytes.NewReader(b)
if err := json.NewDecoder(r).Decode(&obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-06 03:37:45 +00:00
}
2015-03-26 15:19:33 +00:00
argstr, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("data", "is not a string")
}
args.Data = argstr
2015-03-06 03:37:45 +00:00
return nil
}
type BlockFilterArgs struct {
Earliest int64
Latest int64
2015-03-27 14:54:54 +00:00
Address []string
Topics [][]string
Skip int
Max int
}
func (args *BlockFilterArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-06 03:37:45 +00:00
var obj []struct {
2015-03-27 14:54:54 +00:00
FromBlock interface{} `json:"fromBlock"`
ToBlock interface{} `json:"toBlock"`
Limit interface{} `json:"limit"`
Offset interface{} `json:"offset"`
Address interface{} `json:"address"`
Topics interface{} `json:"topics"`
2015-03-06 03:37:45 +00:00
}
if err = json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-06 03:37:45 +00:00
}
// 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
2015-03-27 14:54:54 +00:00
// if blank then latest
if obj[0].FromBlock == nil {
num = -1
} else {
if err := blockHeight(obj[0].FromBlock, &num); err != nil {
return err
}
}
2015-03-27 14:54:54 +00:00
// if -2 or other "silly" number, use latest
if num < 0 {
args.Earliest = -1 //latest block
} else {
args.Earliest = num
}
2015-03-27 14:54:54 +00:00
// if blank than latest
if obj[0].ToBlock == nil {
num = -1
} else {
if err := blockHeight(obj[0].ToBlock, &num); err != nil {
return err
}
2015-03-16 14:38:57 +00:00
}
args.Latest = num
2015-03-16 14:38:57 +00:00
2015-03-27 14:54:54 +00:00
if obj[0].Limit == nil {
num = defaultLogLimit
} else {
if err := numString(obj[0].Limit, &num); err != nil {
return err
}
}
args.Max = int(num)
2015-03-27 14:54:54 +00:00
if obj[0].Offset == nil {
num = defaultLogOffset
} else {
if err := numString(obj[0].Offset, &num); err != nil {
return err
}
2015-03-16 14:38:57 +00:00
}
args.Skip = int(num)
2015-03-16 14:38:57 +00:00
2015-03-27 14:54:54 +00:00
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")
}
}
2015-03-06 03:37:45 +00:00
return nil
}
type DbArgs struct {
Database string
Key string
2015-03-23 15:04:21 +00:00
Value []byte
}
2015-03-06 03:37:45 +00:00
func (args *DbArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
2015-03-23 15:04:21 +00:00
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
if len(obj) < 2 {
return NewInsufficientParamsError(len(obj), 2)
2015-03-06 03:37:45 +00:00
}
2015-03-23 15:04:21 +00:00
var objstr string
var ok bool
if objstr, ok = obj[0].(string); !ok {
return NewInvalidTypeError("database", "not a string")
2015-03-23 15:04:21 +00:00
}
args.Database = objstr
if objstr, ok = obj[1].(string); !ok {
return NewInvalidTypeError("key", "not a string")
2015-03-23 15:04:21 +00:00
}
args.Key = objstr
2015-03-06 03:37:45 +00:00
if len(obj) > 2 {
2015-03-23 15:04:21 +00:00
objstr, ok = obj[2].(string)
if !ok {
return NewInvalidTypeError("value", "not a string")
2015-03-23 15:04:21 +00:00
}
args.Value = []byte(objstr)
2015-03-06 03:37:45 +00:00
}
return nil
}
func (a *DbArgs) requirements() error {
if len(a.Database) == 0 {
return NewValidationError("Database", "cannot be blank")
}
if len(a.Key) == 0 {
return NewValidationError("Key", "cannot be blank")
}
return nil
}
2015-03-23 15:04:21 +00:00
type DbHexArgs struct {
Database string
Key string
Value []byte
}
func (args *DbHexArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
if len(obj) < 2 {
return NewInsufficientParamsError(len(obj), 2)
}
var objstr string
var ok bool
if objstr, ok = obj[0].(string); !ok {
return NewInvalidTypeError("database", "not a string")
2015-03-23 15:04:21 +00:00
}
args.Database = objstr
if objstr, ok = obj[1].(string); !ok {
return NewInvalidTypeError("key", "not a string")
2015-03-23 15:04:21 +00:00
}
args.Key = objstr
if len(obj) > 2 {
objstr, ok = obj[2].(string)
if !ok {
return NewInvalidTypeError("value", "not a string")
2015-03-23 15:04:21 +00:00
}
args.Value = common.FromHex(objstr)
}
return nil
}
func (a *DbHexArgs) requirements() error {
if len(a.Database) == 0 {
2015-03-26 18:39:40 +00:00
return NewValidationError("Database", "cannot be blank")
2015-03-23 15:04:21 +00:00
}
if len(a.Key) == 0 {
2015-03-26 18:39:40 +00:00
return NewValidationError("Key", "cannot be blank")
2015-03-23 15:04:21 +00:00
}
return nil
}
type WhisperMessageArgs struct {
Payload string
To string
From string
2015-03-11 15:56:44 +00:00
Topics []string
Priority uint32
Ttl uint32
}
2015-03-06 03:37:45 +00:00
func (args *WhisperMessageArgs) UnmarshalJSON(b []byte) (err error) {
var obj []struct {
Payload string
To string
From string
2015-03-11 15:56:44 +00:00
Topics []string
2015-03-26 20:07:50 +00:00
Priority interface{}
Ttl interface{}
2015-03-06 03:37:45 +00:00
}
if err = json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-06 03:37:45 +00:00
}
args.Payload = obj[0].Payload
args.To = obj[0].To
args.From = obj[0].From
2015-03-11 15:56:44 +00:00
args.Topics = obj[0].Topics
2015-03-26 20:07:50 +00:00
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)
2015-03-06 03:37:45 +00:00
return nil
}
type CompileArgs struct {
Source string
}
func (args *CompileArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
2015-03-26 19:31:00 +00:00
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
2015-03-26 19:31:00 +00:00
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
argstr, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("arg0", "is not a string")
2015-03-06 03:37:45 +00:00
}
2015-03-26 19:31:00 +00:00
args.Source = argstr
2015-03-06 03:37:45 +00:00
return nil
}
type FilterStringArgs struct {
Word string
}
func (args *FilterStringArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-13 14:03:19 +00:00
var obj []interface{}
2015-03-06 03:37:45 +00:00
r := bytes.NewReader(b)
if err := json.NewDecoder(r).Decode(&obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-06 03:37:45 +00:00
}
2015-03-13 14:03:19 +00:00
var argstr string
argstr, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("filter", "not a string")
2015-03-13 14:03:19 +00:00
}
2015-03-26 19:04:03 +00:00
switch argstr {
2015-03-20 02:58:07 +00:00
case "latest", "pending":
break
default:
return NewValidationError("Word", "Must be `latest` or `pending`")
}
2015-03-26 19:04:03 +00:00
args.Word = argstr
2015-03-20 02:58:07 +00:00
return nil
}
2015-03-06 03:37:45 +00:00
type FilterIdArgs struct {
Id int
}
func (args *FilterIdArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-26 19:10:31 +00:00
var obj []interface{}
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-06 03:37:45 +00:00
}
2015-03-26 19:10:31 +00:00
var num int64
if err := numString(obj[0], &num); err != nil {
return err
}
args.Id = int(num)
2015-03-06 03:37:45 +00:00
return nil
}
type WhisperIdentityArgs struct {
Identity string
}
func (args *WhisperIdentityArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-26 19:20:43 +00:00
var obj []interface{}
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-06 03:37:45 +00:00
}
2015-03-26 19:20:43 +00:00
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
2015-03-06 03:37:45 +00:00
return nil
}
type WhisperFilterArgs struct {
2015-03-06 15:54:08 +00:00
To string `json:"to"`
2015-03-06 03:37:45 +00:00
From string
Topics []string
}
func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
2015-03-06 15:54:08 +00:00
var obj []struct {
2015-03-26 19:52:09 +00:00
To interface{}
Topics []interface{}
2015-03-06 15:54:08 +00:00
}
2015-03-06 03:37:45 +00:00
if err = json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
2015-03-06 03:37:45 +00:00
}
2015-03-26 19:52:09 +00:00
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
2015-03-06 03:37:45 +00:00
return nil
}
type SubmitWorkArgs struct {
Nonce uint64
2015-03-26 21:35:42 +00:00
Header string
Digest string
}
func (args *SubmitWorkArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
if err = json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
if len(obj) < 3 {
return NewInsufficientParamsError(len(obj), 3)
}
var objstr string
var ok bool
if objstr, ok = obj[0].(string); !ok {
return NewInvalidTypeError("nonce", "not a string")
}
2015-03-23 16:33:01 +00:00
args.Nonce = common.String2Big(objstr).Uint64()
if objstr, ok = obj[1].(string); !ok {
return NewInvalidTypeError("header", "not a string")
}
2015-03-26 21:35:42 +00:00
args.Header = objstr
if objstr, ok = obj[2].(string); !ok {
return NewInvalidTypeError("digest", "not a string")
}
2015-03-26 21:35:42 +00:00
args.Digest = objstr
return nil
}