aboutsummaryrefslogtreecommitdiffstats
path: root/rpc/api/admin_args.go
blob: 5437971caa04c357d0e15fab9bf15d6c3349bd75 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
package api

import (
    "encoding/json"

    "github.com/ethereum/go-ethereum/rpc/shared"
)

type AddPeerArgs struct {
    Url string
}

func (args *AddPeerArgs) UnmarshalJSON(b []byte) (err error) {
    var obj []interface{}
    if err := json.Unmarshal(b, &obj); err != nil {
        return shared.NewDecodeParamError(err.Error())
    }

    if len(obj) != 1 {
        return shared.NewDecodeParamError("Expected enode as argument")
    }

    urlstr, ok := obj[0].(string)
    if !ok {
        return shared.NewInvalidTypeError("url", "not a string")
    }
    args.Url = urlstr

    return nil
}

type ImportExportChainArgs struct {
    Filename string
}

func (args *ImportExportChainArgs) UnmarshalJSON(b []byte) (err error) {
    var obj []interface{}
    if err := json.Unmarshal(b, &obj); err != nil {
        return shared.NewDecodeParamError(err.Error())
    }

    if len(obj) != 1 {
        return shared.NewDecodeParamError("Expected filename as argument")
    }

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

    return nil
}

type VerbosityArgs struct {
    Level int
}

func (args *VerbosityArgs) UnmarshalJSON(b []byte) (err error) {
    var obj []interface{}
    if err := json.Unmarshal(b, &obj); err != nil {
        return shared.NewDecodeParamError(err.Error())
    }

    if len(obj) != 1 {
        return shared.NewDecodeParamError("Expected enode as argument")
    }

    level, err := numString(obj[0])
    if err == nil {
        args.Level = int(level.Int64())
    }

    return nil
}

type SetSolcArgs struct {
    Path string
}

func (args *SetSolcArgs) UnmarshalJSON(b []byte) (err error) {
    var obj []interface{}
    if err := json.Unmarshal(b, &obj); err != nil {
        return shared.NewDecodeParamError(err.Error())
    }

    if len(obj) != 1 {
        return shared.NewDecodeParamError("Expected path as argument")
    }

    if pathstr, ok := obj[0].(string); ok {
        args.Path = pathstr
        return nil
    }

    return shared.NewInvalidTypeError("path", "not a string")
}

type StartRPCArgs struct {
    ListenAddress string
    ListenPort    uint
    CorsDomain    string
    Apis          string
}

func (args *StartRPCArgs) UnmarshalJSON(b []byte) (err error) {
    var obj []interface{}
    if err := json.Unmarshal(b, &obj); err != nil {
        return shared.NewDecodeParamError(err.Error())
    }

    args.ListenAddress = "127.0.0.1"
    args.ListenPort = 8545
    args.Apis = "net,eth,web3"

    if len(obj) >= 1 {
        if addr, ok := obj[0].(string); ok {
            args.ListenAddress = addr
        } else {
            return shared.NewInvalidTypeError("listenAddress", "not a string")
        }
    }

    if len(obj) >= 2 {
        if port, ok := obj[1].(float64); ok && port >= 0 && port <= 64*1024 {
            args.ListenPort = uint(port)
        } else {
            return shared.NewInvalidTypeError("listenPort", "not a valid port number")
        }
    }

    if len(obj) >= 3 {
        if corsDomain, ok := obj[2].(string); ok {
            args.CorsDomain = corsDomain
        } else {
            return shared.NewInvalidTypeError("corsDomain", "not a string")
        }
    }

    if len(obj) >= 4 {
        if apis, ok := obj[3].(string); ok {
            args.Apis = apis
        } else {
            return shared.NewInvalidTypeError("apis", "not a string")
        }
    }

    return nil
}