/
genesis.go
100 lines (79 loc) · 2.58 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
package internal
import (
sdk "github.com/Finschia/finschia-sdk/types"
"github.com/Finschia/finschia-sdk/x/foundation"
)
func (k Keeper) InitGenesis(ctx sdk.Context, data *foundation.GenesisState) error {
k.SetParams(ctx, data.Params)
k.SetFoundationInfo(ctx, data.Foundation)
k.setPreviousProposalID(ctx, data.PreviousProposalId)
for _, member := range data.Members {
if err := validateMetadata(member.Metadata, k.config); err != nil {
return err
}
k.SetMember(ctx, member)
}
for _, proposal := range data.Proposals {
if err := validateMetadata(proposal.Metadata, k.config); err != nil {
return err
}
k.setProposal(ctx, proposal)
k.addProposalToVPEndQueue(ctx, proposal)
}
for _, vote := range data.Votes {
if err := validateMetadata(vote.Metadata, k.config); err != nil {
return err
}
k.setVote(ctx, vote)
}
for _, censorship := range data.Censorships {
k.SetCensorship(ctx, censorship)
}
for _, ga := range data.Authorizations {
grantee := sdk.MustAccAddressFromBech32(ga.Grantee)
k.setAuthorization(ctx, grantee, ga.GetAuthorization())
}
k.SetPool(ctx, data.Pool)
return nil
}
func (k Keeper) ExportGenesis(ctx sdk.Context) *foundation.GenesisState {
info := k.GetFoundationInfo(ctx)
proposals := k.GetProposals(ctx)
var votes []foundation.Vote
for _, proposal := range proposals {
votes = append(votes, k.GetVotes(ctx, proposal.Id)...)
}
return &foundation.GenesisState{
Params: k.GetParams(ctx),
Foundation: info,
Members: k.GetMembers(ctx),
PreviousProposalId: k.getPreviousProposalID(ctx),
Proposals: proposals,
Votes: votes,
Censorships: k.GetCensorships(ctx),
Authorizations: k.GetGrants(ctx),
Pool: k.GetPool(ctx),
}
}
func (k Keeper) GetCensorships(ctx sdk.Context) []foundation.Censorship {
var censorships []foundation.Censorship
k.iterateCensorships(ctx, func(censorship foundation.Censorship) (stop bool) {
censorships = append(censorships, censorship)
return false
})
return censorships
}
func (k Keeper) GetGrants(ctx sdk.Context) []foundation.GrantAuthorization {
var grantAuthorizations []foundation.GrantAuthorization
k.iterateAuthorizations(ctx, func(grantee sdk.AccAddress, authorization foundation.Authorization) (stop bool) {
grantAuthorization := foundation.GrantAuthorization{
Grantee: grantee.String(),
}
if err := grantAuthorization.SetAuthorization(authorization); err != nil {
panic(err)
}
grantAuthorizations = append(grantAuthorizations, grantAuthorization)
return false
})
return grantAuthorizations
}