-
Notifications
You must be signed in to change notification settings - Fork 44
/
genesis.go
138 lines (117 loc) · 4.17 KB
/
genesis.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
package keeper
import (
"fmt"
"github.com/desmos-labs/desmos/v3/x/subspaces/types"
sdk "github.com/cosmos/cosmos-sdk/types"
)
// ExportGenesis returns the GenesisState associated with the given context
func (k Keeper) ExportGenesis(ctx sdk.Context) *types.GenesisState {
subspaceID, err := k.GetSubspaceID(ctx)
if err != nil {
panic(err)
}
return types.NewGenesisState(
subspaceID,
k.GetGenesisSubspaces(ctx, k.GetAllSubspaces(ctx)),
k.GetAllPermissions(ctx),
k.GetAllUserGroups(ctx),
k.GetUserAllGroupsMembers(ctx),
)
}
// GetGenesisSubspaces maps the given subspaces to the corresponding GenesisSubspace instance
func (k Keeper) GetGenesisSubspaces(ctx sdk.Context, subspaces []types.Subspace) []types.GenesisSubspace {
if subspaces == nil {
return nil
}
genesisSubspaces := make([]types.GenesisSubspace, len(subspaces))
for i, subspace := range subspaces {
groupID, err := k.GetGroupID(ctx, subspace.ID)
if err != nil {
panic(err)
}
genesisSubspaces[i] = types.NewGenesisSubspace(subspace, groupID)
}
return genesisSubspaces
}
// GetAllPermissions returns all the stored permissions for all subspaces
func (k Keeper) GetAllPermissions(ctx sdk.Context) []types.ACLEntry {
var entries []types.ACLEntry
k.IterateSubspaces(ctx, func(index int64, subspace types.Subspace) (stop bool) {
k.IterateSubspacePermissions(ctx, subspace.ID, func(index int64, user sdk.AccAddress, permission types.Permission) (stop bool) {
entries = append(entries, types.NewACLEntry(subspace.ID, user.String(), permission))
return false
})
return false
})
return entries
}
// GetAllUserGroups returns the information (name and members) for all the groups of all the subspaces
func (k Keeper) GetAllUserGroups(ctx sdk.Context) []types.UserGroup {
var groups []types.UserGroup
k.IterateUserGroups(ctx, func(index int64, group types.UserGroup) (stop bool) {
groups = append(groups, group)
return false
})
return groups
}
// GetUserAllGroupsMembers returns all the UserGroupMembersEntry
func (k Keeper) GetUserAllGroupsMembers(ctx sdk.Context) []types.UserGroupMembersEntry {
var entries []types.UserGroupMembersEntry
k.IterateUserGroups(ctx, func(index int64, group types.UserGroup) (stop bool) {
// Skip group ID 0 to avoid exporting any member
if group.ID == 0 {
return false
}
// Get the group members
members := k.GetGroupMembers(ctx, group.SubspaceID, group.ID)
membersAddr := make([]string, len(members))
for i, member := range members {
membersAddr[i] = member.String()
}
entries = append(entries, types.NewUserGroupMembersEntry(group.SubspaceID, group.ID, membersAddr))
return false
})
return entries
}
// --------------------------------------------------------------------------------------------------------------------
// InitGenesis initializes the chain state based on the given GenesisState
func (k Keeper) InitGenesis(ctx sdk.Context, data types.GenesisState) {
// Initialize the subspaces
for _, subspaceData := range data.Subspaces {
k.SaveSubspace(ctx, subspaceData.Subspace)
k.SetGroupID(ctx, subspaceData.Subspace.ID, subspaceData.InitialGroupID)
}
// Initialize the subspace id setting it to be the max id found + 1
k.SetSubspaceID(ctx, data.InitialSubspaceID)
// Initialize the groups with default permission PermissionNothing
// The real permission will be set later when initializing the various permissions
for _, group := range data.UserGroups {
k.SaveUserGroup(ctx, group)
}
// Initialize the group members
for _, entry := range data.UserGroupsMembers {
// Skip group ID 0 since it's the default group and no user should be here
if entry.GroupID == 0 {
continue
}
// Initialize the members
for _, member := range entry.Members {
userAddr, err := sdk.AccAddressFromBech32(member)
if err != nil {
panic(err)
}
err = k.AddUserToGroup(ctx, entry.SubspaceID, entry.GroupID, userAddr)
if err != nil {
panic(err)
}
}
}
// Initialize the permissions
for _, entry := range data.ACL {
userAddr, err := sdk.AccAddressFromBech32(entry.User)
if err != nil {
panic(fmt.Errorf("invalid user address: %s", entry.User))
}
k.SetUserPermissions(ctx, entry.SubspaceID, userAddr, entry.Permissions)
}
}