plugeth/rpc/args.go

1202 lines
24 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 (
"encoding/json"
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 {
2015-04-04 11:25:47 +00:00
case "earliest":
*number = 0
case "latest":
*number = -1
case "pending":
*number = -2
default:
if common.HasHexPrefix(str) {
*number = common.String2Big(str).Int64()
} else {
return NewInvalidTypeError("blockNumber", "is not a valid string")
}
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{}) (*big.Int, error) {
var number *big.Int
// Parse as integer
num, ok := raw.(float64)
if ok {
number = big.NewInt(int64(num))
return number, nil
}
// Parse as string/hexstring
str, ok := raw.(string)
if ok {
number = common.String2Big(str)
return number, nil
}
return nil, NewInvalidTypeError("", "not a number or string")
}
// 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{}
2015-03-28 20:41:34 +00:00
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-06 03:37:45 +00:00
}
2015-04-02 11:17:55 +00:00
if len(obj) < 2 {
return NewInsufficientParamsError(len(obj), 2)
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
2015-04-02 11:17:55 +00:00
args.IncludeTxs = obj[1].(bool)
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{}
2015-03-28 20:41:34 +00:00
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
2015-04-02 11:17:55 +00:00
if len(obj) < 2 {
return NewInsufficientParamsError(len(obj), 2)
2015-03-06 03:37:45 +00:00
}
if err := blockHeight(obj[0], &args.BlockNumber); err != nil {
return err
}
2015-04-02 11:17:55 +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
Nonce *big.Int
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-05-22 11:00:04 +00:00
type NewSigArgs struct {
From string
Data string
}
2015-05-08 14:17:19 +00:00
2015-05-22 11:00:04 +00:00
func (args *NewSigArgs) UnmarshalJSON(b []byte) (err error) {
var obj []json.RawMessage
var ext struct {
From string
Data string
}
2015-05-08 15:52:44 +00:00
2015-05-22 11:00:04 +00:00
// Decode byte slice to array of RawMessages
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
2015-05-08 15:52:44 +00:00
2015-05-22 11:00:04 +00:00
// Check for sufficient params
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
2015-05-08 15:52:44 +00:00
2015-05-22 11:00:04 +00:00
// Decode 0th RawMessage to temporary struct
if err := json.Unmarshal(obj[0], &ext); err != nil {
return NewDecodeParamError(err.Error())
}
2015-05-08 15:52:44 +00:00
2015-05-22 11:00:04 +00:00
if len(ext.From) == 0 {
return NewValidationError("from", "is required")
}
2015-05-08 15:52:44 +00:00
2015-05-22 11:00:04 +00:00
if len(ext.Data) == 0 {
return NewValidationError("data", "is required")
}
2015-05-08 15:52:44 +00:00
2015-05-22 11:00:04 +00:00
args.From = ext.From
args.Data = ext.Data
return nil
}
2015-05-08 15:52:44 +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
Nonce interface{}
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 *big.Int
if ext.Nonce != nil {
num, err = numString(ext.Nonce)
if err != nil {
return err
}
}
args.Nonce = num
if ext.Value == nil {
num = big.NewInt(0)
} else {
num, err = numString(ext.Value)
if err != nil {
return err
}
}
args.Value = num
num = nil
if ext.Gas == nil {
num = big.NewInt(0)
} else {
if num, err = numString(ext.Gas); err != nil {
return err
}
}
args.Gas = num
num = nil
if ext.GasPrice == nil {
num = big.NewInt(0)
} else {
if num, err = numString(ext.GasPrice); err != nil {
return err
}
}
args.GasPrice = num
2015-03-18 19:42:57 +00:00
// Check for optional BlockNumber param
if len(obj) > 1 {
if err := blockHeightFromJson(obj[1], &args.BlockNumber); err != nil {
return err
}
2015-04-02 09:57:26 +00:00
} else {
args.BlockNumber = -1
}
return nil
}
type CallArgs struct {
From string
To string
Value *big.Int
Gas *big.Int
GasPrice *big.Int
Data string
BlockNumber int64
}
func (args *CallArgs) UnmarshalJSON(b []byte) (err error) {
var obj []json.RawMessage
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 {
return NewDecodeParamError(err.Error())
}
// 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-04-18 00:32:55 +00:00
args.From = ext.From
if len(ext.To) == 0 {
return NewValidationError("to", "is required")
}
args.To = ext.To
var num *big.Int
if ext.Value == nil {
num = big.NewInt(0)
} else {
if num, err = numString(ext.Value); err != nil {
return err
}
}
args.Value = num
if ext.Gas == nil {
num = big.NewInt(0)
} else {
if num, err = numString(ext.Gas); err != nil {
return err
}
}
args.Gas = num
if ext.GasPrice == nil {
num = big.NewInt(0)
} else {
if num, err = numString(ext.GasPrice); err != nil {
return err
}
}
args.GasPrice = num
args.Data = ext.Data
// Check for optional BlockNumber param
2015-03-18 19:42:57 +00:00
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-04-02 09:57:26 +00:00
} else {
args.BlockNumber = -1
2015-03-18 19:42:57 +00:00
}
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-04-02 09:57:26 +00:00
} else {
args.BlockNumber = -1
2015-03-18 19:42:57 +00:00
}
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-04-02 09:57:26 +00:00
} else {
args.BlockNumber = -1
2015-03-18 19:42:57 +00:00
}
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-04-02 09:57:26 +00:00
} else {
args.BlockNumber = -1
2015-03-18 19:42:57 +00:00
}
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-04-02 09:57:26 +00:00
} else {
args.BlockNumber = -1
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-04-02 09:57:26 +00:00
} else {
args.BlockNumber = -1
2015-03-18 19:42:57 +00:00
}
2015-03-06 03:37:45 +00:00
return nil
2015-01-20 19:57:51 +00:00
}
2015-04-02 11:17:55 +00:00
type BlockNumArg struct {
BlockNumber int64
}
func (args *BlockNumArg) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
if err := blockHeight(obj[0], &args.BlockNumber); err != nil {
return err
}
return nil
}
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{}
2015-03-28 20:41:34 +00:00
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-11 20:26:28 +00:00
}
2015-04-02 11:17:55 +00:00
if len(obj) < 2 {
return NewInsufficientParamsError(len(obj), 2)
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
}
2015-04-22 18:24:10 +00:00
var arg1 *big.Int
if arg1, err = numString(obj[1]); err != nil {
return err
2015-04-02 11:17:55 +00:00
}
2015-04-22 18:24:10 +00:00
args.Index = arg1.Int64()
2015-04-02 11:17:55 +00:00
return nil
}
type HashArgs struct {
Hash string
}
func (args *HashArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
arg0, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("hash", "not a string")
2015-03-11 20:26:28 +00:00
}
2015-04-02 11:17:55 +00:00
args.Hash = arg0
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{}
2015-03-28 20:41:34 +00:00
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
2015-03-11 20:26:28 +00:00
}
2015-04-02 11:17:55 +00:00
if len(obj) < 2 {
return NewInsufficientParamsError(len(obj), 2)
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
2015-04-02 11:17:55 +00:00
arg1, ok := obj[1].(string)
if !ok {
return NewInvalidTypeError("index", "not a string")
2015-03-11 20:26:28 +00:00
}
2015-04-02 11:17:55 +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{}
2015-03-28 20:41:34 +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 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
var numBig *big.Int
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 {
numBig = big.NewInt(defaultLogLimit)
2015-03-27 14:54:54 +00:00
} else {
if numBig, err = numString(obj[0].Limit); err != nil {
2015-03-27 14:54:54 +00:00
return err
}
}
args.Max = int(numBig.Int64())
2015-03-27 14:54:54 +00:00
if obj[0].Offset == nil {
numBig = big.NewInt(defaultLogOffset)
2015-03-27 14:54:54 +00:00
} else {
if numBig, err = numString(obj[0].Offset); err != nil {
2015-03-27 14:54:54 +00:00
return err
}
2015-03-16 14:38:57 +00:00
}
args.Skip = int(numBig.Int64())
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 if jv == nil {
topicdbl[i][j] = ""
2015-03-27 14:54:54 +00:00
} else {
return NewInvalidTypeError(fmt.Sprintf("topic[%d][%d]", i, j), "is not a string")
}
}
} else if iv == nil {
topicdbl[i] = []string{""}
2015-03-27 14:54:54 +00:00
} 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 *big.Int
if num, err = numString(obj[0].Priority); err != nil {
2015-03-26 20:07:50 +00:00
return err
}
args.Priority = uint32(num.Int64())
2015-03-26 20:07:50 +00:00
if num, err = numString(obj[0].Ttl); err != nil {
2015-03-26 20:07:50 +00:00
return err
}
args.Ttl = uint32(num.Int64())
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-28 20:41:34 +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-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
}
var num *big.Int
if num, err = numString(obj[0]); err != nil {
2015-03-26 19:10:31 +00:00
return err
}
args.Id = int(num.Int64())
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 {
To string
2015-03-06 03:37:45 +00:00
From string
Topics [][]string
2015-03-06 03:37:45 +00:00
}
// UnmarshalJSON implements the json.Unmarshaler interface, invoked to convert a
// JSON message blob into a WhisperFilterArgs structure.
2015-03-06 03:37:45 +00:00
func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
// Unmarshal the JSON message and sanity check
2015-03-06 15:54:08 +00:00
var obj []struct {
To interface{} `json:"to"`
From interface{} `json:"from"`
Topics interface{} `json:"topics"`
2015-03-06 15:54:08 +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
}
// Retrieve the simple data contents of the filter arguments
if obj[0].To == nil {
args.To = ""
} else {
argstr, ok := obj[0].To.(string)
if !ok {
return NewInvalidTypeError("to", "is not a string")
}
args.To = argstr
2015-03-26 19:52:09 +00:00
}
if obj[0].From == nil {
args.From = ""
} else {
argstr, ok := obj[0].From.(string)
2015-03-26 19:52:09 +00:00
if !ok {
return NewInvalidTypeError("from", "is not a string")
2015-03-26 19:52:09 +00:00
}
args.From = argstr
}
// Construct the nested topic array
if obj[0].Topics != nil {
// Make sure we have an actual topic array
list, ok := obj[0].Topics.([]interface{})
if !ok {
return NewInvalidTypeError("topics", "is not an array")
}
// Iterate over each topic and handle nil, string or array
topics := make([][]string, len(list))
for idx, field := range list {
switch value := field.(type) {
case nil:
topics[idx] = []string{}
case string:
topics[idx] = []string{value}
case []interface{}:
topics[idx] = make([]string, len(value))
for i, nested := range value {
switch value := nested.(type) {
case nil:
topics[idx][i] = ""
case string:
topics[idx][i] = value
default:
return NewInvalidTypeError(fmt.Sprintf("topic[%d][%d]", idx, i), "is not a string")
}
}
default:
return NewInvalidTypeError(fmt.Sprintf("topic[%d]", idx), "not a string or array")
}
}
args.Topics = topics
2015-03-26 19:52:09 +00:00
}
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
}
type SourceArgs struct {
Source string
}
func (args *SourceArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
arg0, ok := obj[0].(string)
if !ok {
return NewInvalidTypeError("source code", "not a string")
}
args.Source = arg0
return nil
}