2021-09-16 06:13:39 -07:00
|
|
|
package keeper
|
|
|
|
|
|
|
|
import (
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
|
|
|
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
|
2021-10-04 09:36:38 -07:00
|
|
|
storetypes "github.com/cosmos/cosmos-sdk/store/types"
|
2021-09-16 06:13:39 -07:00
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
|
|
db "github.com/tendermint/tm-db"
|
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
DefaultEpochActionID = 1
|
|
|
|
DefaultEpochNumber = 0
|
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
NextEpochActionID = []byte{0x11}
|
|
|
|
EpochNumberID = []byte{0x12}
|
|
|
|
EpochActionQueuePrefix = []byte{0x13} // prefix for the epoch
|
|
|
|
)
|
|
|
|
|
|
|
|
// Keeper of the store
|
|
|
|
type Keeper struct {
|
2021-10-04 09:36:38 -07:00
|
|
|
storeKey storetypes.StoreKey
|
2021-09-16 06:13:39 -07:00
|
|
|
cdc codec.BinaryCodec
|
|
|
|
// Used to calculate the estimated next epoch time.
|
|
|
|
// This is local to every node
|
|
|
|
// TODO: remove in favor of consensus param when its added
|
|
|
|
commitTimeout time.Duration
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewKeeper creates a epoch queue manager
|
2021-10-04 09:36:38 -07:00
|
|
|
func NewKeeper(cdc codec.BinaryCodec, key storetypes.StoreKey, commitTimeout time.Duration) Keeper {
|
2021-09-16 06:13:39 -07:00
|
|
|
return Keeper{
|
|
|
|
storeKey: key,
|
|
|
|
cdc: cdc,
|
|
|
|
commitTimeout: commitTimeout,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetNewActionID returns ID to be used for next epoch
|
|
|
|
func (k Keeper) GetNewActionID(ctx sdk.Context) uint64 {
|
|
|
|
store := ctx.KVStore(k.storeKey)
|
|
|
|
|
|
|
|
bz := store.Get(NextEpochActionID)
|
|
|
|
if bz == nil {
|
|
|
|
// return default action ID to 1
|
|
|
|
return DefaultEpochActionID
|
|
|
|
}
|
|
|
|
id := sdk.BigEndianToUint64(bz)
|
|
|
|
|
|
|
|
// increment next action ID
|
|
|
|
store.Set(NextEpochActionID, sdk.Uint64ToBigEndian(id+1))
|
|
|
|
|
|
|
|
return id
|
|
|
|
}
|
|
|
|
|
|
|
|
// ActionStoreKey returns action store key from ID
|
|
|
|
func ActionStoreKey(epochNumber int64, actionID uint64) []byte {
|
|
|
|
return append(EpochActionQueuePrefix, byte(epochNumber), byte(actionID))
|
|
|
|
}
|
|
|
|
|
|
|
|
// QueueMsgForEpoch save the actions that need to be executed on next epoch
|
|
|
|
func (k Keeper) QueueMsgForEpoch(ctx sdk.Context, epochNumber int64, msg sdk.Msg) {
|
|
|
|
store := ctx.KVStore(k.storeKey)
|
|
|
|
|
|
|
|
bz, err := k.cdc.MarshalInterface(msg)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
actionID := k.GetNewActionID(ctx)
|
|
|
|
store.Set(ActionStoreKey(epochNumber, actionID), bz)
|
|
|
|
}
|
|
|
|
|
|
|
|
// RestoreEpochAction restore the actions that need to be executed on next epoch
|
|
|
|
func (k Keeper) RestoreEpochAction(ctx sdk.Context, epochNumber int64, action *codectypes.Any) {
|
|
|
|
store := ctx.KVStore(k.storeKey)
|
|
|
|
|
|
|
|
// reference from TestMarshalAny(t *testing.T)
|
|
|
|
bz, err := k.cdc.MarshalInterface(action)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
actionID := k.GetNewActionID(ctx)
|
|
|
|
store.Set(ActionStoreKey(epochNumber, actionID), bz)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetEpochMsg gets a msg by ID
|
|
|
|
func (k Keeper) GetEpochMsg(ctx sdk.Context, epochNumber int64, actionID uint64) sdk.Msg {
|
|
|
|
store := ctx.KVStore(k.storeKey)
|
|
|
|
|
|
|
|
bz := store.Get(ActionStoreKey(epochNumber, actionID))
|
|
|
|
if bz == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var action sdk.Msg
|
|
|
|
k.cdc.UnmarshalInterface(bz, &action)
|
|
|
|
|
|
|
|
return action
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetEpochActions get all actions
|
|
|
|
func (k Keeper) GetEpochActions(ctx sdk.Context) []sdk.Msg {
|
|
|
|
actions := []sdk.Msg{}
|
2021-10-30 06:43:04 -07:00
|
|
|
iterator := k.GetEpochActionsIterator(ctx)
|
2021-09-16 06:13:39 -07:00
|
|
|
defer iterator.Close()
|
|
|
|
|
|
|
|
for ; iterator.Valid(); iterator.Next() {
|
|
|
|
var action sdk.Msg
|
|
|
|
bz := iterator.Value()
|
|
|
|
k.cdc.UnmarshalInterface(bz, &action)
|
|
|
|
actions = append(actions, action)
|
|
|
|
}
|
|
|
|
|
|
|
|
return actions
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetEpochActionsIterator returns iterator for EpochActions
|
|
|
|
func (k Keeper) GetEpochActionsIterator(ctx sdk.Context) db.Iterator {
|
2021-10-30 06:43:04 -07:00
|
|
|
return sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), EpochActionQueuePrefix)
|
2021-09-16 06:13:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// DequeueEpochActions dequeue all the actions store on epoch
|
|
|
|
func (k Keeper) DequeueEpochActions(ctx sdk.Context) {
|
|
|
|
store := ctx.KVStore(k.storeKey)
|
2021-10-30 06:43:04 -07:00
|
|
|
iterator := sdk.KVStorePrefixIterator(store, EpochActionQueuePrefix)
|
2021-09-16 06:13:39 -07:00
|
|
|
defer iterator.Close()
|
|
|
|
|
|
|
|
for ; iterator.Valid(); iterator.Next() {
|
|
|
|
key := iterator.Key()
|
|
|
|
store.Delete(key)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// DeleteByKey delete item by key
|
|
|
|
func (k Keeper) DeleteByKey(ctx sdk.Context, key []byte) {
|
|
|
|
store := ctx.KVStore(k.storeKey)
|
|
|
|
store.Delete(key)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetEpochActionByIterator get action by iterator
|
|
|
|
func (k Keeper) GetEpochActionByIterator(iterator db.Iterator) sdk.Msg {
|
|
|
|
bz := iterator.Value()
|
|
|
|
|
|
|
|
var action sdk.Msg
|
|
|
|
k.cdc.UnmarshalInterface(bz, &action)
|
|
|
|
|
|
|
|
return action
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetEpochNumber set epoch number
|
|
|
|
func (k Keeper) SetEpochNumber(ctx sdk.Context, epochNumber int64) {
|
|
|
|
store := ctx.KVStore(k.storeKey)
|
|
|
|
store.Set(EpochNumberID, sdk.Uint64ToBigEndian(uint64(epochNumber)))
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetEpochNumber fetches epoch number
|
|
|
|
func (k Keeper) GetEpochNumber(ctx sdk.Context) int64 {
|
|
|
|
store := ctx.KVStore(k.storeKey)
|
|
|
|
|
|
|
|
bz := store.Get(EpochNumberID)
|
|
|
|
if bz == nil {
|
|
|
|
return DefaultEpochNumber
|
|
|
|
}
|
|
|
|
|
|
|
|
return int64(sdk.BigEndianToUint64(bz))
|
|
|
|
}
|
|
|
|
|
|
|
|
// IncreaseEpochNumber increases epoch number
|
|
|
|
func (k Keeper) IncreaseEpochNumber(ctx sdk.Context) {
|
|
|
|
epochNumber := k.GetEpochNumber(ctx)
|
|
|
|
k.SetEpochNumber(ctx, epochNumber+1)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetNextEpochHeight returns next epoch block height
|
|
|
|
func (k Keeper) GetNextEpochHeight(ctx sdk.Context, epochInterval int64) int64 {
|
|
|
|
currentHeight := ctx.BlockHeight()
|
|
|
|
return currentHeight + (epochInterval - currentHeight%epochInterval)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetNextEpochTime returns estimated next epoch time
|
|
|
|
func (k Keeper) GetNextEpochTime(ctx sdk.Context, epochInterval int64) time.Time {
|
|
|
|
currentTime := ctx.BlockTime()
|
|
|
|
currentHeight := ctx.BlockHeight()
|
|
|
|
|
|
|
|
return currentTime.Add(k.commitTimeout * time.Duration(k.GetNextEpochHeight(ctx, epochInterval)-currentHeight))
|
|
|
|
}
|