aboutsummaryrefslogblamecommitdiffstats
path: root/rpc/args.go
blob: aa7d205498bc82279ac223f3b9880ee68b589c6a (plain) (tree)
1
2
3
4
5
6
7
8
9

           

                       
             
                  
 
                                                
 
 




                              








                                                                    
                           
                                
               
                                    





                                    
                                                                        

         
                    

                           


                            
                            
                




                                                                                          
         
 


                  

                                                   


                                

                                               



                                    


                                               
         
 
                                                                     

 



















                                                                            










                                                              
                                
                         
                       

 

                                                                     

                                                       
                                                       

         

                                                              
         


                                     
                                                                       
         
                               
 
                                       

                  

 
                                  

                         

 

                                                                       
                                                       
                                                       

         

                                                              
         
 

                                                                      
         
 
                                       
 
                  

 




























                                                              
                       

                       
                         



                         
 
                         

 



                        
 
                                                             
                             
 


                                                       
 



                                                              
 


                                                                  
         
                        
 
                                

                                                                
 






                                                                  

                                                                
 

                  
 
                                                            
                                 


                               
                                    




                                    



                                                       

         









                                                              



                                                                

                            

                            
                        







                                               
                             
                                   
                

                                               


                                  
                        
 
                 
                           
                                                              

                                  

                         
         
                      
 
                 
                                
                                                                   

                                  

                         
         
                           
 
                                               



                                                                                      

                                     









































                                                              

                            




                                                              
                        
                             
                                   
                
                                                                


                                  
                        
 
                           
                                                              

                                  

                         
         
                      
 
                                
                                                                   

                                  

                         
         
                           



                                               
                         
                                                                                      

                                  

                                     
         
 



                            
                          
                         

 
                                                                 

                                                       
                                                       
         
 





                                                              
                                                                     
         
                             

                         
                                                                              

                                  

                                     

         
                  

 
                              

                          
                         

 
                                                                   

                                                       
                                                       
         
 
                         
                                                              
         
 

                                     
                                                                     
         
                             


                                     
                                                                 
         
                         

                         
                                                                              

                                  

                                     
         
 
                  

 
                            
                          
                         

 
                                                                 

                                                       
                                                       

         





                                                              
                                                                     
         
                             

                         
                                                                              

                                  

                                     

         
                  

 
                            
                          
                         

 
                                                                 
                             
                                                       
                                                       


                         
                                                              



                                     
                                                                     
         
                             

                         
                                                                              
                                  
                 

                                     

         
                  

 
                         
                          
                         

 
                                                              

                                                       
                                                       

         





                                                              
                                                                     
         
                             

                         
                                                                              

                                  

                                     

         
                  

 




















                                                                      

                               
                         

 

                                                                    
                                                       
                                                       

         

                                                              

         

                                                                      
         
 


                                                      
         
                                 




















                                                                  
         
                        



                  
                           
                    
                   

 

                                                                
                                                       
                                                       

         

                                                              



                                   
                                                                  
         
                        
 


                                                                   
         
                                             



                  



                      

                                                           
                                                       
                                                       


                         
                                                              
         
 




                                                                     


                  
                             

                      

                           



                    
                                                                  
                          





                                                        


                                                      
                                                       


                         
                                                              
         
 







                                                                            
                     
                           







                                                                           
         
                                                    



                                                 

         






                                                                         
         
                         
 
                                
                                                    
                
                                                                      

                                  
         
                                      
 
                                 
                                                     
                
                                                                       

                                  
         
                                       
 







































                                                                                                                    

                                                                           



                                                                                                                                         

                                                                  









                                                                                                                        



                  


                       
                       

 

                                                         
                                                       
                                                       


                         
                                                              
         




                                              
                                                                      



                                              
                                                                 

                         

                         

                                            
                                                                           


                                           




                  

                                       
                                                                        

                            
                                                                   


                  
 



















                                                              
                                                                      



                                              
                                                                 





                                            
                                                                           









                                                   
                                                                        

                            
                                                                   



                  



                                
                         


                       





                                                                     
                                 

                                    


                                                      
                                                       


                         
                                                              



                                     
                                   
 

                                                              

                          
                                           
 
                                                         

                          
                                      









                                                              
                                                       
                                                       

         





                                                                     
         
                            








                                                                   
                             
                                                       
                                                       


                         
                                                              

         


                                     
                                                                    
         
                       




                                                                                  
                          


                  




                                                               

                                                       
                                                       


                         
                                                              

         

                                                     

                          
                                  








                                                                      

                                                       
                                                       


                         
                                                              

         







                                                                    




                               
                     
                     
                         

 

                                                                                
                                                                    
                                                      
                          


                                                  
         
                                                       
                                                       
         
                         
                                                              
         
                                                                    







                                                                           
         



                                                  
                        
                                                                             
                 













                                                                               
                                                        






















                                                                                                                                   
         

                  


                            

                     














                                                                 
                                                                   

         
                                                       
                                              
                                                                    

         
                            

                                              
                                                                    

         
                            


                  






















                                                                         
package rpc

import (
    "encoding/json"
    "fmt"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
)

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 {
        *number = int64(num)
        return nil
    }

    // Parse as string/hexstring
    str, ok := raw.(string)
    if !ok {
        return NewInvalidTypeError("", "not a number or string")
    }

    switch str {
    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")
        }
    }

    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
//  }
// }

// 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
}

func (args *GetBlockByHashArgs) 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)
    }

    argstr, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("blockHash", "not a string")
    }
    args.BlockHash = argstr

    args.IncludeTxs = obj[1].(bool)

    return nil
}

type GetBlockByNumberArgs struct {
    BlockNumber int64
    IncludeTxs  bool
}

func (args *GetBlockByNumberArgs) 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)
    }

    if err := blockHeight(obj[0], &args.BlockNumber); err != nil {
        return err
    }

    args.IncludeTxs = obj[1].(bool)

    return nil
}

type NewDataArgs struct {
    Data string
}

func (args *NewDataArgs) UnmarshalJSON(b []byte) (err error) {
    var obj []interface{}

    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)
    }

    data, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("data", "not a string")
    }
    args.Data = data

    if len(args.Data) == 0 {
        return NewValidationError("data", "is required")
    }

    return nil
}

type NewTxArgs struct {
    From     string
    To       string
    Nonce    *big.Int
    Value    *big.Int
    Gas      *big.Int
    GasPrice *big.Int
    Data     string

    BlockNumber int64
}

type NewSigArgs struct {
    From string
    Data string
}

func (args *NewSigArgs) UnmarshalJSON(b []byte) (err error) {
    var obj []interface{}

    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)
    }

    from, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("from", "not a string")
    }
    args.From = from

    if len(args.From) == 0 {
        return NewValidationError("from", "is required")
    }

    data, ok := obj[1].(string)
    if !ok {
        return NewInvalidTypeError("data", "not a string")
    }
    args.Data = data

    if len(args.Data) == 0 {
        return NewValidationError("data", "is required")
    }

    return nil
}

func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
    var obj []json.RawMessage
    var ext struct {
        From     string
        To       string
        Nonce    interface{}
        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())
    }

    if len(ext.From) == 0 {
        return NewValidationError("from", "is required")
    }

    args.From = ext.From
    args.To = ext.To
    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 {
        if num, err = numString(ext.Gas); err != nil {
            return err
        }
    } else {
        num = nil
    }
    args.Gas = num

    num = nil
    if ext.GasPrice != nil {
        if num, err = numString(ext.GasPrice); err != nil {
            return err
        }
    } else {
        num = nil
    }
    args.GasPrice = num

    // Check for optional BlockNumber param
    if len(obj) > 1 {
        if err := blockHeightFromJson(obj[1], &args.BlockNumber); err != nil {
            return err
        }
    } 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())
    }

    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 {
        if num, err = numString(ext.Gas); err != nil {
            return err
        }
    } else {
        num = nil
    }
    args.Gas = num

    if ext.GasPrice != nil {
        if num, err = numString(ext.GasPrice); err != nil {
            return err
        }
    } else {
        num = nil
    }
    args.GasPrice = num

    args.Data = ext.Data

    // Check for optional BlockNumber param
    if len(obj) > 1 {
        if err := blockHeightFromJson(obj[1], &args.BlockNumber); err != nil {
            return err
        }
    } else {
        args.BlockNumber = -1
    }

    return nil
}

type GetStorageArgs struct {
    Address     string
    BlockNumber int64
}

func (args *GetStorageArgs) 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)
    }

    addstr, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("address", "not a string")
    }
    args.Address = addstr

    if len(obj) > 1 {
        if err := blockHeight(obj[1], &args.BlockNumber); err != nil {
            return err
        }
    } else {
        args.BlockNumber = -1
    }

    return nil
}

type GetStorageAtArgs struct {
    Address     string
    Key         string
    BlockNumber int64
}

func (args *GetStorageAtArgs) 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)
    }

    addstr, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("address", "not a string")
    }
    args.Address = addstr

    keystr, ok := obj[1].(string)
    if !ok {
        return NewInvalidTypeError("key", "not a string")
    }
    args.Key = keystr

    if len(obj) > 2 {
        if err := blockHeight(obj[2], &args.BlockNumber); err != nil {
            return err
        }
    } else {
        args.BlockNumber = -1
    }

    return nil
}

type GetTxCountArgs struct {
    Address     string
    BlockNumber int64
}

func (args *GetTxCountArgs) 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)
    }

    addstr, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("address", "not a string")
    }
    args.Address = addstr

    if len(obj) > 1 {
        if err := blockHeight(obj[1], &args.BlockNumber); err != nil {
            return err
        }
    } else {
        args.BlockNumber = -1
    }

    return nil
}

type GetBalanceArgs struct {
    Address     string
    BlockNumber int64
}

func (args *GetBalanceArgs) 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)
    }

    addstr, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("address", "not a string")
    }
    args.Address = addstr

    if len(obj) > 1 {
        if err := blockHeight(obj[1], &args.BlockNumber); err != nil {
            return err
        }
    } else {
        args.BlockNumber = -1
    }

    return nil
}

type GetDataArgs struct {
    Address     string
    BlockNumber int64
}

func (args *GetDataArgs) 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)
    }

    addstr, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("address", "not a string")
    }
    args.Address = addstr

    if len(obj) > 1 {
        if err := blockHeight(obj[1], &args.BlockNumber); err != nil {
            return err
        }
    } else {
        args.BlockNumber = -1
    }

    return nil
}

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
}

type BlockNumIndexArgs struct {
    BlockNumber int64
    Index       int64
}

func (args *BlockNumIndexArgs) 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)
    }

    if err := blockHeight(obj[0], &args.BlockNumber); err != nil {
        return err
    }

    var arg1 *big.Int
    if arg1, err = numString(obj[1]); err != nil {
        return err
    }
    args.Index = arg1.Int64()

    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")
    }
    args.Hash = arg0

    return nil
}

type HashIndexArgs struct {
    Hash  string
    Index int64
}

func (args *HashIndexArgs) 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)
    }

    arg0, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("hash", "not a string")
    }
    args.Hash = arg0

    arg1, ok := obj[1].(string)
    if !ok {
        return NewInvalidTypeError("index", "not a string")
    }
    args.Index = common.Big(arg1).Int64()

    return nil
}

type Sha3Args struct {
    Data string
}

func (args *Sha3Args) 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)
    }

    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  []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     interface{} `json:"limit"`
        Offset    interface{} `json:"offset"`
        Address   interface{} `json:"address"`
        Topics    interface{} `json:"topics"`
    }

    if err = json.Unmarshal(b, &obj); err != nil {
        return NewDecodeParamError(err.Error())
    }

    if len(obj) < 1 {
        return NewInsufficientParamsError(len(obj), 1)
    }

    // 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

    // if blank then latest
    if obj[0].FromBlock == nil {
        num = -1
    } else {
        if err := blockHeight(obj[0].FromBlock, &num); err != nil {
            return err
        }
    }
    // if -2 or other "silly" number, use latest
    if num < 0 {
        args.Earliest = -1 //latest block
    } else {
        args.Earliest = num
    }

    // 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 {
        numBig = big.NewInt(defaultLogLimit)
    } else {
        if numBig, err = numString(obj[0].Limit); err != nil {
            return err
        }
    }
    args.Max = int(numBig.Int64())

    if obj[0].Offset == nil {
        numBig = big.NewInt(defaultLogOffset)
    } else {
        if numBig, err = numString(obj[0].Offset); err != nil {
            return err
        }
    }
    args.Skip = int(numBig.Int64())

    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] = ""
                        } else {
                            return NewInvalidTypeError(fmt.Sprintf("topic[%d][%d]", i, j), "is not a string")
                        }
                    }
                } else if iv == nil {
                    topicdbl[i] = []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
}

type DbArgs struct {
    Database string
    Key      string
    Value    []byte
}

func (args *DbArgs) 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")
    }
    args.Database = objstr

    if objstr, ok = obj[1].(string); !ok {
        return NewInvalidTypeError("key", "not a string")
    }
    args.Key = objstr

    if len(obj) > 2 {
        objstr, ok = obj[2].(string)
        if !ok {
            return NewInvalidTypeError("value", "not a string")
        }

        args.Value = []byte(objstr)
    }

    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
}

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")
    }
    args.Database = objstr

    if objstr, ok = obj[1].(string); !ok {
        return NewInvalidTypeError("key", "not a string")
    }
    args.Key = objstr

    if len(obj) > 2 {
        objstr, ok = obj[2].(string)
        if !ok {
            return NewInvalidTypeError("value", "not a string")
        }

        args.Value = common.FromHex(objstr)
    }

    return nil
}

func (a *DbHexArgs) 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
}

type WhisperMessageArgs struct {
    Payload  string
    To       string
    From     string
    Topics   []string
    Priority uint32
    Ttl      uint32
}

func (args *WhisperMessageArgs) UnmarshalJSON(b []byte) (err error) {
    var obj []struct {
        Payload  string
        To       string
        From     string
        Topics   []string
        Priority interface{}
        Ttl      interface{}
    }

    if err = json.Unmarshal(b, &obj); err != nil {
        return NewDecodeParamError(err.Error())
    }

    if len(obj) < 1 {
        return NewInsufficientParamsError(len(obj), 1)
    }
    args.Payload = obj[0].Payload
    args.To = obj[0].To
    args.From = obj[0].From
    args.Topics = obj[0].Topics

    var num *big.Int
    if num, err = numString(obj[0].Priority); err != nil {
        return err
    }
    args.Priority = uint32(num.Int64())

    if num, err = numString(obj[0].Ttl); err != nil {
        return err
    }
    args.Ttl = uint32(num.Int64())

    return nil
}

type CompileArgs struct {
    Source string
}

func (args *CompileArgs) 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)
    }
    argstr, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("arg0", "is not a string")
    }
    args.Source = argstr

    return nil
}

type FilterStringArgs struct {
    Word string
}

func (args *FilterStringArgs) 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)
    }

    var argstr string
    argstr, ok := obj[0].(string)
    if !ok {
        return NewInvalidTypeError("filter", "not a string")
    }
    switch argstr {
    case "latest", "pending":
        break
    default:
        return NewValidationError("Word", "Must be `latest` or `pending`")
    }
    args.Word = argstr
    return nil
}

type FilterIdArgs struct {
    Id int
}

func (args *FilterIdArgs) 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)
    }

    var num *big.Int
    if num, err = numString(obj[0]); err != nil {
        return err
    }
    args.Id = int(num.Int64())

    return nil
}

type WhisperIdentityArgs struct {
    Identity string
}

func (args *WhisperIdentityArgs) 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)
    }

    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
}

type WhisperFilterArgs struct {
    To     string
    From   string
    Topics [][]string
}

// UnmarshalJSON implements the json.Unmarshaler interface, invoked to convert a
// JSON message blob into a WhisperFilterArgs structure.
func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
    // Unmarshal the JSON message and sanity check
    var obj []struct {
        To     interface{} `json:"to"`
        From   interface{} `json:"from"`
        Topics interface{} `json:"topics"`
    }
    if err := json.Unmarshal(b, &obj); err != nil {
        return NewDecodeParamError(err.Error())
    }
    if len(obj) < 1 {
        return NewInsufficientParamsError(len(obj), 1)
    }
    // 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
    }
    if obj[0].From == nil {
        args.From = ""
    } else {
        argstr, ok := obj[0].From.(string)
        if !ok {
            return NewInvalidTypeError("from", "is not a string")
        }
        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
    }
    return nil
}

type SubmitWorkArgs struct {
    Nonce  uint64
    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")
    }

    args.Nonce = common.String2Big(objstr).Uint64()
    if objstr, ok = obj[1].(string); !ok {
        return NewInvalidTypeError("header", "not a string")
    }

    args.Header = objstr

    if objstr, ok = obj[2].(string); !ok {
        return NewInvalidTypeError("digest", "not a string")
    }

    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
}