/
invariants.go
97 lines (80 loc) · 3.02 KB
/
invariants.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
package keeper
import (
"fmt"
"github.com/desmos-labs/desmos/v3/x/subspaces/types"
sdk "github.com/cosmos/cosmos-sdk/types"
)
// RegisterInvariants registers all subspaces invariants
func RegisterInvariants(ir sdk.InvariantRegistry, keeper Keeper) {
ir.RegisterRoute(types.ModuleName, "valid-subspaces",
ValidSubspacesInvariant(keeper))
ir.RegisterRoute(types.ModuleName, "valid-user-groups",
ValidUserGroupsInvariant(keeper))
}
// AllInvariants runs all invariants of the module
func AllInvariants(k Keeper) sdk.Invariant {
return func(ctx sdk.Context) (string, bool) {
res, broken := ValidSubspacesInvariant(k)(ctx)
if broken {
return res, true
}
res, broken = ValidUserGroupsInvariant(k)(ctx)
if broken {
return res, true
}
return "Every invariant condition is fulfilled correctly", false
}
}
// --------------------------------------------------------------------------------------------------------------------
// ValidSubspacesInvariant checks that all the subspaces are valid
func ValidSubspacesInvariant(k Keeper) sdk.Invariant {
return func(ctx sdk.Context) (string, bool) {
var invalidSubspaces []types.Subspace
k.IterateSubspaces(ctx, func(_ int64, subspace types.Subspace) (stop bool) {
err := subspace.Validate()
if err != nil {
invalidSubspaces = append(invalidSubspaces, subspace)
}
return false
})
return sdk.FormatInvariant(types.ModuleName, "invalid subspaces",
fmt.Sprintf("the following subspaces are invalid:\n %s", formatOutputSubspaces(invalidSubspaces)),
), invalidSubspaces != nil
}
}
// formatOutputSubspaces concatenate the subspaces given into a unique string
func formatOutputSubspaces(subspaces []types.Subspace) (outputSubspaces string) {
for _, subspace := range subspaces {
outputSubspaces += fmt.Sprintf("%d\n", subspace.ID)
}
return outputSubspaces
}
// --------------------------------------------------------------------------------------------------------------------
// ValidUserGroupsInvariant checks that all the subspaces are valid
func ValidUserGroupsInvariant(k Keeper) sdk.Invariant {
return func(ctx sdk.Context) (string, bool) {
var invalidUserGroups []types.UserGroup
k.IterateUserGroups(ctx, func(_ int64, group types.UserGroup) (stop bool) {
err := group.Validate()
if err != nil {
// The group is not valid
invalidUserGroups = append(invalidUserGroups, group)
}
if !k.HasSubspace(ctx, group.SubspaceID) {
// The subspace for this group does not exist anymore
invalidUserGroups = append(invalidUserGroups, group)
}
return false
})
return sdk.FormatInvariant(types.ModuleName, "invalid user groups",
fmt.Sprintf("the following user groups are invalid:\n %s", formatOutputUserGroups(invalidUserGroups)),
), invalidUserGroups != nil
}
}
// formatOutputUserGroups concatenate the subspaces given into a unique string
func formatOutputUserGroups(groups []types.UserGroup) (outputUserGroups string) {
for _, group := range groups {
outputUserGroups += fmt.Sprintf("%d\n", group.ID)
}
return outputUserGroups
}