/
params.go
154 lines (124 loc) · 3.99 KB
/
params.go
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
150
151
152
153
154
package types
import (
"bytes"
"fmt"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/params"
)
// guard params default values
const (
// Default number of guards for guarding request
DefaultRequestGuardCount uint64 = 3
// Default minimal channel dispute timeout in mainchain blocks
DefaultMinDisputeTimeout uint64 = 80000
)
var (
// Default cost per request
DefaultRequestCost = sdk.NewInt(1000000000000000000)
)
// nolint - Keys for parameter access
var (
KeyRequestGuardCount = []byte("RequestGuardCount")
KeyRequestCost = []byte("RequestCost")
KeyMinDisputeTimeout = []byte("MinDisputeTimeout")
)
var _ params.ParamSet = (*Params)(nil)
// Params defines the high level settings for guard
type Params struct {
RequestGuardCount uint64 `json:"request_guard_count" yaml:"request_guard_count"` // request guard count
RequestCost sdk.Int `json:"request_cost" yaml:"request_cost"` // request cost
MinDisputeTimeout uint64 `json:"min_dispute_timeout" yaml:"min_dispute_timeout"` // minimal channel dispute timeout in mainchain blocks
}
// NewParams creates a new Params instance
func NewParams(requestGuardCount uint64, requestCost sdk.Int, minDisputeTimeout uint64) Params {
return Params{
RequestGuardCount: requestGuardCount,
RequestCost: requestCost,
MinDisputeTimeout: minDisputeTimeout,
}
}
// Implements params.ParamSet
func (p *Params) ParamSetPairs() params.ParamSetPairs {
return params.ParamSetPairs{
params.NewParamSetPair(KeyRequestGuardCount, &p.RequestGuardCount, validateRequestGuardCount),
params.NewParamSetPair(KeyRequestCost, &p.RequestCost, validateRequestCost),
params.NewParamSetPair(KeyMinDisputeTimeout, &p.MinDisputeTimeout, validateMinDisputeTimeout),
}
}
// Equal returns a boolean determining if two Param types are identical.
func (p Params) Equal(p2 Params) bool {
bz1 := ModuleCdc.MustMarshalBinaryLengthPrefixed(&p)
bz2 := ModuleCdc.MustMarshalBinaryLengthPrefixed(&p2)
return bytes.Equal(bz1, bz2)
}
// DefaultParams returns a default set of parameters.
func DefaultParams() Params {
return NewParams(DefaultRequestGuardCount, DefaultRequestCost, DefaultMinDisputeTimeout)
}
// String returns a human readable string representation of the parameters.
func (p Params) String() string {
return fmt.Sprintf(`Params:
RequestGuardCount: %d,
RequestCost: %s
MinDisputeTimeout: %d`, p.RequestGuardCount, p.RequestCost, p.MinDisputeTimeout)
}
// unmarshal the current guard params value from store key or panic
func MustUnmarshalParams(cdc *codec.Codec, value []byte) Params {
params, err := UnmarshalParams(cdc, value)
if err != nil {
panic(err)
}
return params
}
// unmarshal the current guard params value from store key
func UnmarshalParams(cdc *codec.Codec, value []byte) (params Params, err error) {
err = cdc.UnmarshalBinaryLengthPrefixed(value, ¶ms)
if err != nil {
return
}
return
}
// validate a set of params
func (p Params) Validate() error {
if err := validateRequestGuardCount(p.RequestGuardCount); err != nil {
return err
}
if err := validateRequestCost(p.RequestCost); err != nil {
return err
}
if err := validateMinDisputeTimeout(p.MinDisputeTimeout); err != nil {
return err
}
return nil
}
func validateRequestGuardCount(i interface{}) error {
v, ok := i.(uint64)
if !ok {
return fmt.Errorf("invalid parameter type: %T", i)
}
if v == 0 {
return fmt.Errorf("guard parameter RequestGuardCount must be positive: %d", v)
}
return nil
}
func validateRequestCost(i interface{}) error {
v, ok := i.(sdk.Int)
if !ok {
return fmt.Errorf("invalid parameter type: %T", i)
}
if v.IsNegative() {
return fmt.Errorf("guard parameter RequestCost cannot be negative: %s", v)
}
return nil
}
func validateMinDisputeTimeout(i interface{}) error {
v, ok := i.(uint64)
if !ok {
return fmt.Errorf("invalid parameter type: %T", i)
}
if v <= 0 {
return fmt.Errorf("guard parameter MinDisputeTimeout must be positive: %d", v)
}
return nil
}