cerc-io/laconicd
17
0
Fork 2
Code Issues 1 Pull Requests 1 Actions Packages Projects Releases 9 Wiki Activity

Implement genesis import and export keepers

Browse Source
This commit is contained in:
Prathamesh Musale 2024-02-22 15:09:40 +05:30
parent 75737915ab
commit 00d821538f
2 changed files with 80 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

105
x/registry/keeper/genesis.go
View File

@ -1,80 +1,99 @@
package keeper package keeper
import ( import (
"context" "time"
sdk "github.com/cosmos/cosmos-sdk/types"
"git.vdb.to/cerc-io/laconic2d/x/registry" "git.vdb.to/cerc-io/laconic2d/x/registry"
) )
// InitGenesis initializes the module state from a genesis state. // InitGenesis initializes the module state from a genesis state.
func (k *Keeper) InitGenesis(ctx context.Context, data *registry.GenesisState) error { func (k *Keeper) InitGenesis(ctx sdk.Context, data *registry.GenesisState) error {
if err := k.Params.Set(ctx, data.Params); err != nil { if err := k.Params.Set(ctx, data.Params); err != nil {
return err return err
} }
// for _, record := range data.Records { for _, record := range data.Records {
// keeper.PutRecord(ctx, record) if err := k.SaveRecord(ctx, record); err != nil {
return err
}
// // Add to record expiry queue if expiry time is in the future. // Add to record expiry queue if expiry time is in the future.
// expiryTime, err := time.Parse(time.RFC3339, record.ExpiryTime) expiryTime, err := time.Parse(time.RFC3339, record.ExpiryTime)
// if err != nil { if err != nil {
// panic(err) panic(err)
// } }
// if expiryTime.After(ctx.BlockTime()) { if expiryTime.After(ctx.BlockTime()) {
// keeper.InsertRecordExpiryQueue(ctx, record) // TODO
// } // k.InsertRecordExpiryQueue(ctx, record)
}
}
// // Note: Bond genesis runs first, so bonds will already be present. for _, authority := range data.Authorities {
// if record.BondId != "" { // Only import authorities that are marked active.
// keeper.AddBondToRecordIndexEntry(ctx, record.BondId, record.Id) if authority.Entry.Status == registry.AuthorityActive {
// } if err := k.SaveNameAuthority(ctx, authority.Name, authority.Entry); err != nil {
// } return err
}
// for _, authority := range data.Authorities { // TODO
// // Only import authorities that are marked active. // Add authority name to expiry queue.
// if authority.Entry.Status == types.AuthorityActive { // k.InsertAuthorityExpiryQueue(ctx, authority.Name, authority.Entry.ExpiryTime)
// keeper.SetNameAuthority(ctx, authority.Name, authority.Entry)
// // Add authority name to expiry queue. // TODO
// keeper.InsertAuthorityExpiryQueue(ctx, authority.Name, authority.Entry.ExpiryTime) // Note: Bond genesis runs first, so bonds will already be present.
// // Note: Bond genesis runs first, so bonds will already be present.
// if authority.Entry.BondId != "" { // if authority.Entry.BondId != "" {
// keeper.AddBondToAuthorityIndexEntry(ctx, authority.Entry.BondId, authority.Name) // k.AddBondToAuthorityIndexEntry(ctx, authority.Entry.BondId, authority.Name)
// }
// }
// } // }
}
}
// for _, nameEntry := range data.Names { for _, nameEntry := range data.Names {
// keeper.SetNameRecord(ctx, nameEntry.Name, nameEntry.Entry.Latest.Id) if err := k.SaveNameRecord(ctx, nameEntry.Name, nameEntry.Entry.Latest.Id); err != nil {
// } return err
}
}
return nil return nil
} }
// ExportGenesis exports the module state to a genesis state. // ExportGenesis exports the module state to a genesis state.
func (k *Keeper) ExportGenesis(ctx context.Context) (*registry.GenesisState, error) { func (k *Keeper) ExportGenesis(ctx sdk.Context) (*registry.GenesisState, error) {
params, err := k.Params.Get(ctx) params, err := k.Params.Get(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// records := keeper.ListRecords(ctx) records, err := k.ListRecords(ctx)
if err != nil {
return nil, err
}
// authorities := keeper.ListNameAuthorityRecords(ctx) authorities, err := k.ListNameAuthorityRecords(ctx)
// authorityEntries := []types.AuthorityEntry{} if err != nil {
// // #nosec G705 return nil, err
// for name, record := range authorities { }
// authorityEntries = append(authorityEntries, types.AuthorityEntry{
// Name: name,
// Entry: &record, //nolint: all
// }) // #nosec G601
// }
// names := keeper.ListNameRecords(ctx) authorityEntries := []registry.AuthorityEntry{}
// #nosec G705
for name, record := range authorities {
authorityEntries = append(authorityEntries, registry.AuthorityEntry{
Name: name,
Entry: &record, //nolint: all
}) // #nosec G601
}
names, err := k.ListNameRecords(ctx)
if err != nil {
return nil, err
}
return &registry.GenesisState{ return &registry.GenesisState{
Params: params, Params: params,
Records: records,
Authorities: authorityEntries,
Names: names,
}, nil }, nil
} }

15
x/registry/keeper/naming_keeper.go
View File

@ -39,6 +39,21 @@ func (k Keeper) GetNameAuthority(ctx sdk.Context, name string) (registrytypes.Na
return authority, nil return authority, nil
} }
// ListNameAuthorityRecords - get all name authority records.
func (k Keeper) ListNameAuthorityRecords(ctx sdk.Context) (map[string]registrytypes.NameAuthority, error) {
nameAuthorityRecords := make(map[string]registrytypes.NameAuthority)
err := k.Authorities.Walk(ctx, nil, func(key string, value registrytypes.NameAuthority) (bool, error) {
nameAuthorityRecords[key] = value
return false, nil
})
if err != nil {
return map[string]registrytypes.NameAuthority{}, err
}
return nameAuthorityRecords, nil
}
// HasNameRecord - checks if a name record exists. // HasNameRecord - checks if a name record exists.
func (k Keeper) HasNameRecord(ctx sdk.Context, crn string) (bool, error) { func (k Keeper) HasNameRecord(ctx sdk.Context, crn string) (bool, error) {
return k.NameRecords.Has(ctx, crn) return k.NameRecords.Has(ctx, crn)