/
params.go
127 lines (102 loc) · 2.92 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
package types
import (
"errors"
"fmt"
sdk "github.com/cosmos/cosmos-sdk/types"
"regexp"
"strings"
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
)
// Parameter store keys
var (
MaxSupply = []byte("MaxSupply")
ExcludeCirculatingAddr = []byte("ExcludeCirculatingAddr")
)
const (
MinMaxSupply = 1_000_000
LimitLengthExcludeCirculatingAddr = 10
)
// Regex using check string is number
var digitCheck = regexp.MustCompile(`^[0-9]+$`)
// ParamTable for aura module.
func ParamKeyTable() paramtypes.KeyTable {
return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
}
func NewParams(maxSupply string, excludeCirculatingAddr []string) Params {
return Params{
MaxSupply: maxSupply,
ExcludeCirculatingAddr: excludeCirculatingAddr,
}
}
// default aura module parameters
func DefaultParams() Params {
return Params{
MaxSupply: "1000000000000000000000000000",
ExcludeCirculatingAddr: []string{},
}
}
// validate params
func (p Params) Validate() error {
if err := validateMaxSupply(p.MaxSupply); err != nil {
return err
}
if err := validateExcludeCirculatingAddr(p.ExcludeCirculatingAddr); err != nil {
return err
}
return nil
}
// Implements params.ParamSet
func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
return paramtypes.ParamSetPairs{
paramtypes.NewParamSetPair(MaxSupply, &p.MaxSupply, validateMaxSupply),
paramtypes.NewParamSetPair(ExcludeCirculatingAddr, &p.ExcludeCirculatingAddr, validateExcludeCirculatingAddr),
}
}
func validateMaxSupply(i interface{}) error {
v, ok := i.(string)
if !ok {
return fmt.Errorf("invalid parameter type: %T", i)
}
if strings.TrimSpace(v) == "" {
return errors.New("max supply cannot be blank")
}
if !digitCheck.MatchString(strings.TrimSpace(v)) {
return errors.New("invalid max supply parameter, expected string as number")
}
vi, err := sdk.NewDecFromStr(v)
if err != nil {
return fmt.Errorf("can not parse max supply to Dec, value=%s", v)
}
if vi.LT(sdk.NewDec(MinMaxSupply)) {
return fmt.Errorf("required max supply greater than %d", MinMaxSupply)
}
return nil
}
func validateExcludeCirculatingAddr(i interface{}) error {
v, ok := i.([]string)
if !ok {
return fmt.Errorf("invalid parameter type: %T", i)
}
if len(v) > LimitLengthExcludeCirculatingAddr {
return errors.New("len of exclude exclude circulating address reach limit")
}
if checkDuplicate(v) {
return errors.New("duplicated address in exclude circulating address")
}
for _, addBech32 := range v {
//if strings.TrimSpace(addBech32) == "" {
// return errors.New("exclude circulating address can not contain blank")
//}
if _, err := sdk.AccAddressFromBech32(addBech32); err != nil {
return errors.New("exclude circulating address invalid format")
}
}
return nil
}
func checkDuplicate(ss []string) bool {
m := make(map[string]bool)
for _, s := range ss {
m[s] = true
}
return !(len(ss) == len(m))
}