0g-chain/x/auction/keeper/keeper.go

217 lines
6.9 KiB
Go
Raw Normal View History

2019-11-25 19:46:02 +00:00
package keeper
import (
"fmt"
"time"
2019-11-25 19:46:02 +00:00
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/store/prefix"
2019-11-25 19:46:02 +00:00
sdk "github.com/cosmos/cosmos-sdk/types"
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
2020-04-30 14:23:41 +00:00
"github.com/tendermint/tendermint/libs/log"
2019-11-25 19:46:02 +00:00
"github.com/kava-labs/kava/x/auction/types"
)
type Keeper struct {
storeKey sdk.StoreKey
cdc codec.Codec
paramSubspace paramtypes.Subspace
bankKeeper types.BankKeeper
accountKeeper types.AccountKeeper
2019-11-25 19:46:02 +00:00
}
// NewKeeper returns a new auction keeper.
func NewKeeper(cdc codec.Codec, storeKey sdk.StoreKey, paramstore paramtypes.Subspace,
bankKeeper types.BankKeeper, accountKeeper types.AccountKeeper) Keeper {
if !paramstore.HasKeyTable() {
paramstore = paramstore.WithKeyTable(types.ParamKeyTable())
}
2019-11-25 19:46:02 +00:00
return Keeper{
storeKey: storeKey,
cdc: cdc,
paramSubspace: paramstore,
accountKeeper: accountKeeper,
bankKeeper: bankKeeper,
}
}
// MustUnmarshalAuction attempts to decode and return an Auction object from
// raw encoded bytes. It panics on error.
func (k Keeper) MustUnmarshalAuction(bz []byte) types.Auction {
auction, err := k.UnmarshalAuction(bz)
if err != nil {
panic(fmt.Errorf("failed to decode auction: %w", err))
2019-11-25 19:46:02 +00:00
}
return auction
}
// MustMarshalAuction attempts to encode an Auction object and returns the
// raw encoded bytes. It panics on error.
func (k Keeper) MustMarshalAuction(auction types.Auction) []byte {
bz, err := k.MarshalAuction(auction)
if err != nil {
panic(fmt.Errorf("failed to encode auction: %w", err))
}
return bz
}
// MarshalAuction protobuf serializes an Auction interface
func (k Keeper) MarshalAuction(auctionI types.Auction) ([]byte, error) {
return k.cdc.MarshalInterface(auctionI)
}
// UnmarshalAuction returns an Auction interface from raw encoded auction
// bytes of a Proto-based Auction type
func (k Keeper) UnmarshalAuction(bz []byte) (types.Auction, error) {
var evi types.Auction
return evi, k.cdc.UnmarshalInterface(bz, &evi)
2019-11-25 19:46:02 +00:00
}
// Logger returns a module-specific logger.
func (k Keeper) Logger(ctx sdk.Context) log.Logger {
return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
2019-11-25 19:46:02 +00:00
}
// SetNextAuctionID stores an ID to be used for the next created auction
func (k Keeper) SetNextAuctionID(ctx sdk.Context, id uint64) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.NextAuctionIDKey)
store.Set(types.NextAuctionIDKey, types.Uint64ToBytes(id))
2019-11-25 19:46:02 +00:00
}
// GetNextAuctionID reads the next available global ID from store
func (k Keeper) GetNextAuctionID(ctx sdk.Context) (uint64, error) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.NextAuctionIDKey)
bz := store.Get(types.NextAuctionIDKey)
if bz == nil {
return 0, types.ErrInvalidInitialAuctionID
2019-11-25 19:46:02 +00:00
}
return types.Uint64FromBytes(bz), nil
2019-11-25 19:46:02 +00:00
}
// IncrementNextAuctionID increments the next auction ID in the store by 1.
func (k Keeper) IncrementNextAuctionID(ctx sdk.Context) error {
id, err := k.GetNextAuctionID(ctx)
2019-11-25 19:46:02 +00:00
if err != nil {
return err
}
k.SetNextAuctionID(ctx, id+1)
2019-11-25 19:46:02 +00:00
return nil
}
// StoreNewAuction stores an auction, adding a new ID
func (k Keeper) StoreNewAuction(ctx sdk.Context, auction types.Auction) (uint64, error) {
newAuctionID, err := k.GetNextAuctionID(ctx)
2019-11-25 19:46:02 +00:00
if err != nil {
return 0, err
2019-11-25 19:46:02 +00:00
}
auction = auction.WithID(newAuctionID)
k.SetAuction(ctx, auction)
2019-11-25 19:46:02 +00:00
err = k.IncrementNextAuctionID(ctx)
if err != nil {
return 0, err
2019-11-25 19:46:02 +00:00
}
return newAuctionID, nil
2019-11-25 19:46:02 +00:00
}
// SetAuction puts the auction into the store, and updates any indexes.
2019-11-25 19:46:02 +00:00
func (k Keeper) SetAuction(ctx sdk.Context, auction types.Auction) {
// remove the auction from the byTime index if it is already in there
2019-11-25 19:46:02 +00:00
existingAuction, found := k.GetAuction(ctx, auction.GetID())
if found {
k.removeFromByTimeIndex(ctx, existingAuction.GetEndTime(), existingAuction.GetID())
2019-11-25 19:46:02 +00:00
}
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.AuctionKeyPrefix)
2019-11-25 19:46:02 +00:00
store.Set(types.GetAuctionKey(auction.GetID()), k.MustMarshalAuction(auction))
k.InsertIntoByTimeIndex(ctx, auction.GetEndTime(), auction.GetID())
2019-11-25 19:46:02 +00:00
}
// GetAuction gets an auction from the store.
func (k Keeper) GetAuction(ctx sdk.Context, auctionID uint64) (types.Auction, bool) {
2019-11-25 19:46:02 +00:00
var auction types.Auction
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.AuctionKeyPrefix)
bz := store.Get(types.GetAuctionKey(auctionID))
2019-11-25 19:46:02 +00:00
if bz == nil {
return auction, false
2019-11-25 19:46:02 +00:00
}
return k.MustUnmarshalAuction(bz), true
2019-11-25 19:46:02 +00:00
}
// DeleteAuction removes an auction from the store, and any indexes.
func (k Keeper) DeleteAuction(ctx sdk.Context, auctionID uint64) {
2019-11-25 19:46:02 +00:00
auction, found := k.GetAuction(ctx, auctionID)
if found {
k.removeFromByTimeIndex(ctx, auction.GetEndTime(), auctionID)
2019-11-25 19:46:02 +00:00
}
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.AuctionKeyPrefix)
store.Delete(types.GetAuctionKey(auctionID))
2019-11-25 19:46:02 +00:00
}
// InsertIntoByTimeIndex adds an auction ID and end time into the byTime index.
func (k Keeper) InsertIntoByTimeIndex(ctx sdk.Context, endTime time.Time, auctionID uint64) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.AuctionByTimeKeyPrefix)
store.Set(types.GetAuctionByTimeKey(endTime, auctionID), types.Uint64ToBytes(auctionID))
2019-11-25 19:46:02 +00:00
}
// removeFromByTimeIndex removes an auction ID and end time from the byTime index.
func (k Keeper) removeFromByTimeIndex(ctx sdk.Context, endTime time.Time, auctionID uint64) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.AuctionByTimeKeyPrefix)
store.Delete(types.GetAuctionByTimeKey(endTime, auctionID))
2019-11-25 19:46:02 +00:00
}
// IterateAuctionByTime provides an iterator over auctions ordered by auction.EndTime.
// For each auction cb will be callled. If cb returns true the iterator will close and stop.
func (k Keeper) IterateAuctionsByTime(ctx sdk.Context, inclusiveCutoffTime time.Time, cb func(auctionID uint64) (stop bool)) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.AuctionByTimeKeyPrefix)
iterator := store.Iterator(
nil, // start at the very start of the prefix store
sdk.PrefixEndBytes(sdk.FormatTimeBytes(inclusiveCutoffTime)), // include any keys with times equal to inclusiveCutoffTime
2019-11-25 19:46:02 +00:00
)
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
2019-11-25 19:46:02 +00:00
auctionID := types.Uint64FromBytes(iterator.Value())
2019-11-25 19:46:02 +00:00
if cb(auctionID) {
break
}
}
2019-11-25 19:46:02 +00:00
}
// IterateAuctions provides an iterator over all stored auctions.
// For each auction, cb will be called. If cb returns true, the iterator will close and stop.
func (k Keeper) IterateAuctions(ctx sdk.Context, cb func(auction types.Auction) (stop bool)) {
iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.storeKey), types.AuctionKeyPrefix)
2019-11-25 19:46:02 +00:00
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
auction := k.MustUnmarshalAuction(iterator.Value())
2019-11-25 19:46:02 +00:00
if cb(auction) {
break
}
}
2019-11-25 19:46:02 +00:00
}
// GetAllAuctions returns all auctions from the store
func (k Keeper) GetAllAuctions(ctx sdk.Context) (auctions []types.Auction) {
k.IterateAuctions(ctx, func(auction types.Auction) bool {
auctions = append(auctions, auction)
return false
})
return
}