github.com/Finschia/finschia-sdk@v0.49.1/x/foundation/keeper/internal/genesis.go (about)

     1  package internal
     2  
     3  import (
     4  	"fmt"
     5  
     6  	sdk "github.com/Finschia/finschia-sdk/types"
     7  	"github.com/Finschia/finschia-sdk/x/foundation"
     8  )
     9  
    10  func (k Keeper) InitGenesis(ctx sdk.Context, data *foundation.GenesisState) error {
    11  	k.SetParams(ctx, data.Params)
    12  
    13  	k.SetFoundationInfo(ctx, data.Foundation)
    14  
    15  	k.setPreviousProposalID(ctx, data.PreviousProposalId)
    16  
    17  	for _, member := range data.Members {
    18  		if err := validateMetadata(member.Metadata, k.config); err != nil {
    19  			return err
    20  		}
    21  
    22  		k.SetMember(ctx, member)
    23  	}
    24  
    25  	for _, proposal := range data.Proposals {
    26  		if err := validateMetadata(proposal.Metadata, k.config); err != nil {
    27  			return err
    28  		}
    29  
    30  		k.setProposal(ctx, proposal)
    31  		k.addProposalToVPEndQueue(ctx, proposal)
    32  	}
    33  
    34  	for _, vote := range data.Votes {
    35  		if err := validateMetadata(vote.Metadata, k.config); err != nil {
    36  			return err
    37  		}
    38  
    39  		k.setVote(ctx, vote)
    40  	}
    41  
    42  	for _, censorship := range data.Censorships {
    43  		k.SetCensorship(ctx, censorship)
    44  	}
    45  
    46  	for _, ga := range data.Authorizations {
    47  		grantee := sdk.MustAccAddressFromBech32(ga.Grantee)
    48  		k.setAuthorization(ctx, grantee, ga.GetAuthorization())
    49  	}
    50  
    51  	k.SetPool(ctx, data.Pool)
    52  
    53  	// init module accounts just in case
    54  	if acc := k.authKeeper.GetModuleAccount(ctx, foundation.ModuleName); acc == nil {
    55  		panic(fmt.Sprintf("failed to create module account=%s", foundation.ModuleName))
    56  	}
    57  	if acc := k.authKeeper.GetModuleAccount(ctx, foundation.TreasuryName); acc == nil {
    58  		panic(fmt.Sprintf("failed to create module account=%s", foundation.TreasuryName))
    59  	}
    60  	return nil
    61  }
    62  
    63  func (k Keeper) ExportGenesis(ctx sdk.Context) *foundation.GenesisState {
    64  	info := k.GetFoundationInfo(ctx)
    65  	proposals := k.GetProposals(ctx)
    66  
    67  	var votes []foundation.Vote
    68  	for _, proposal := range proposals {
    69  		votes = append(votes, k.GetVotes(ctx, proposal.Id)...)
    70  	}
    71  
    72  	return &foundation.GenesisState{
    73  		Params:             k.GetParams(ctx),
    74  		Foundation:         info,
    75  		Members:            k.GetMembers(ctx),
    76  		PreviousProposalId: k.getPreviousProposalID(ctx),
    77  		Proposals:          proposals,
    78  		Votes:              votes,
    79  		Censorships:        k.GetCensorships(ctx),
    80  		Authorizations:     k.GetGrants(ctx),
    81  		Pool:               k.GetPool(ctx),
    82  	}
    83  }
    84  
    85  func (k Keeper) GetCensorships(ctx sdk.Context) []foundation.Censorship {
    86  	var censorships []foundation.Censorship
    87  	k.iterateCensorships(ctx, func(censorship foundation.Censorship) (stop bool) {
    88  		censorships = append(censorships, censorship)
    89  
    90  		return false
    91  	})
    92  	return censorships
    93  }
    94  
    95  func (k Keeper) GetGrants(ctx sdk.Context) []foundation.GrantAuthorization {
    96  	var grantAuthorizations []foundation.GrantAuthorization
    97  	k.iterateAuthorizations(ctx, func(grantee sdk.AccAddress, authorization foundation.Authorization) (stop bool) {
    98  		grantAuthorization := foundation.GrantAuthorization{
    99  			Grantee: grantee.String(),
   100  		}
   101  		if err := grantAuthorization.SetAuthorization(authorization); err != nil {
   102  			panic(err)
   103  		}
   104  		grantAuthorizations = append(grantAuthorizations, grantAuthorization)
   105  
   106  		return false
   107  	})
   108  	return grantAuthorizations
   109  }