mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-11-10 10:05:18 +00:00
251 lines
8.5 KiB
Go
251 lines
8.5 KiB
Go
package keeper
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
|
"github.com/cosmos/cosmos-sdk/store/prefix"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
|
|
"github.com/tendermint/tendermint/libs/log"
|
|
|
|
"github.com/kava-labs/kava/x/bep3/types"
|
|
)
|
|
|
|
// Keeper of the bep3 store
|
|
type Keeper struct {
|
|
key sdk.StoreKey
|
|
cdc codec.Codec
|
|
paramSubspace paramtypes.Subspace
|
|
bankKeeper types.BankKeeper
|
|
accountKeeper types.AccountKeeper
|
|
Maccs map[string]bool
|
|
}
|
|
|
|
// NewKeeper creates a bep3 keeper
|
|
func NewKeeper(cdc codec.Codec, key sdk.StoreKey, sk types.BankKeeper, ak types.AccountKeeper,
|
|
paramstore paramtypes.Subspace, maccs map[string]bool,
|
|
) Keeper {
|
|
if !paramstore.HasKeyTable() {
|
|
paramstore = paramstore.WithKeyTable(types.ParamKeyTable())
|
|
}
|
|
|
|
keeper := Keeper{
|
|
key: key,
|
|
cdc: cdc,
|
|
paramSubspace: paramstore,
|
|
bankKeeper: sk,
|
|
accountKeeper: ak,
|
|
Maccs: maccs,
|
|
}
|
|
return keeper
|
|
}
|
|
|
|
// 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))
|
|
}
|
|
|
|
// ------------------------------------------
|
|
// Atomic Swaps
|
|
// ------------------------------------------
|
|
|
|
// SetAtomicSwap puts the AtomicSwap into the store, and updates any indexes.
|
|
func (k Keeper) SetAtomicSwap(ctx sdk.Context, atomicSwap types.AtomicSwap) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AtomicSwapKeyPrefix)
|
|
bz := k.cdc.MustMarshal(&atomicSwap)
|
|
store.Set(atomicSwap.GetSwapID(), bz)
|
|
}
|
|
|
|
// GetAtomicSwap gets an AtomicSwap from the store.
|
|
func (k Keeper) GetAtomicSwap(ctx sdk.Context, swapID []byte) (types.AtomicSwap, bool) {
|
|
var atomicSwap types.AtomicSwap
|
|
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AtomicSwapKeyPrefix)
|
|
bz := store.Get(swapID)
|
|
if bz == nil {
|
|
return atomicSwap, false
|
|
}
|
|
|
|
k.cdc.MustUnmarshal(bz, &atomicSwap)
|
|
return atomicSwap, true
|
|
}
|
|
|
|
// RemoveAtomicSwap removes an AtomicSwap from the AtomicSwapKeyPrefix.
|
|
func (k Keeper) RemoveAtomicSwap(ctx sdk.Context, swapID []byte) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AtomicSwapKeyPrefix)
|
|
store.Delete(swapID)
|
|
}
|
|
|
|
// IterateAtomicSwaps provides an iterator over all stored AtomicSwaps.
|
|
// For each AtomicSwap, cb will be called. If cb returns true, the iterator will close and stop.
|
|
func (k Keeper) IterateAtomicSwaps(ctx sdk.Context, cb func(atomicSwap types.AtomicSwap) (stop bool)) {
|
|
iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.key), types.AtomicSwapKeyPrefix)
|
|
|
|
defer iterator.Close()
|
|
for ; iterator.Valid(); iterator.Next() {
|
|
var atomicSwap types.AtomicSwap
|
|
k.cdc.MustUnmarshal(iterator.Value(), &atomicSwap)
|
|
|
|
if cb(atomicSwap) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// GetAllAtomicSwaps returns all AtomicSwaps from the store
|
|
func (k Keeper) GetAllAtomicSwaps(ctx sdk.Context) (atomicSwaps types.AtomicSwaps) {
|
|
k.IterateAtomicSwaps(ctx, func(atomicSwap types.AtomicSwap) bool {
|
|
atomicSwaps = append(atomicSwaps, atomicSwap)
|
|
return false
|
|
})
|
|
return
|
|
}
|
|
|
|
// ------------------------------------------
|
|
// Atomic Swap Block Index
|
|
// ------------------------------------------
|
|
|
|
// InsertIntoByBlockIndex adds a swap ID and expiration time into the byBlock index.
|
|
func (k Keeper) InsertIntoByBlockIndex(ctx sdk.Context, atomicSwap types.AtomicSwap) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AtomicSwapByBlockPrefix)
|
|
store.Set(types.GetAtomicSwapByHeightKey(atomicSwap.ExpireHeight, atomicSwap.GetSwapID()), atomicSwap.GetSwapID())
|
|
}
|
|
|
|
// RemoveFromByBlockIndex removes an AtomicSwap from the byBlock index.
|
|
func (k Keeper) RemoveFromByBlockIndex(ctx sdk.Context, atomicSwap types.AtomicSwap) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AtomicSwapByBlockPrefix)
|
|
store.Delete(types.GetAtomicSwapByHeightKey(atomicSwap.ExpireHeight, atomicSwap.GetSwapID()))
|
|
}
|
|
|
|
// IterateAtomicSwapsByBlock provides an iterator over AtomicSwaps ordered by AtomicSwap expiration block
|
|
// For each AtomicSwap cb will be called. If cb returns true the iterator will close and stop.
|
|
func (k Keeper) IterateAtomicSwapsByBlock(ctx sdk.Context, inclusiveCutoffTime uint64, cb func(swapID []byte) (stop bool)) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AtomicSwapByBlockPrefix)
|
|
iterator := store.Iterator(
|
|
nil, // start at the very start of the prefix store
|
|
sdk.PrefixEndBytes(sdk.Uint64ToBigEndian(inclusiveCutoffTime)), // end of range
|
|
)
|
|
|
|
defer iterator.Close()
|
|
for ; iterator.Valid(); iterator.Next() {
|
|
|
|
id := iterator.Value()
|
|
|
|
if cb(id) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------
|
|
// Atomic Swap Longterm Storage Index
|
|
// ------------------------------------------
|
|
|
|
// InsertIntoLongtermStorage adds a swap ID and deletion time into the longterm storage index.
|
|
// Completed swaps are stored for 1 week.
|
|
func (k Keeper) InsertIntoLongtermStorage(ctx sdk.Context, atomicSwap types.AtomicSwap) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AtomicSwapLongtermStoragePrefix)
|
|
deletionHeight := uint64(atomicSwap.ClosedBlock) + types.DefaultLongtermStorageDuration
|
|
store.Set(types.GetAtomicSwapByHeightKey(deletionHeight, atomicSwap.GetSwapID()), atomicSwap.GetSwapID())
|
|
}
|
|
|
|
// RemoveFromLongtermStorage removes a swap from the into the longterm storage index
|
|
func (k Keeper) RemoveFromLongtermStorage(ctx sdk.Context, atomicSwap types.AtomicSwap) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AtomicSwapLongtermStoragePrefix)
|
|
deletionHeight := uint64(atomicSwap.ClosedBlock) + types.DefaultLongtermStorageDuration
|
|
store.Delete(types.GetAtomicSwapByHeightKey(deletionHeight, atomicSwap.GetSwapID()))
|
|
}
|
|
|
|
// IterateAtomicSwapsLongtermStorage provides an iterator over AtomicSwaps ordered by deletion height.
|
|
// For each AtomicSwap cb will be called. If cb returns true the iterator will close and stop.
|
|
func (k Keeper) IterateAtomicSwapsLongtermStorage(ctx sdk.Context, inclusiveCutoffTime uint64,
|
|
cb func(swapID []byte) (stop bool),
|
|
) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AtomicSwapLongtermStoragePrefix)
|
|
iterator := store.Iterator(
|
|
nil, // start at the very start of the prefix store
|
|
sdk.PrefixEndBytes(sdk.Uint64ToBigEndian(inclusiveCutoffTime)), // end of range
|
|
)
|
|
|
|
defer iterator.Close()
|
|
for ; iterator.Valid(); iterator.Next() {
|
|
|
|
id := iterator.Value()
|
|
|
|
if cb(id) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------
|
|
// Asset Supplies
|
|
// ------------------------------------------
|
|
|
|
// GetAssetSupply gets an asset's current supply from the store.
|
|
func (k Keeper) GetAssetSupply(ctx sdk.Context, denom string) (types.AssetSupply, bool) {
|
|
var assetSupply types.AssetSupply
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AssetSupplyPrefix)
|
|
bz := store.Get([]byte(denom))
|
|
if bz == nil {
|
|
return types.AssetSupply{}, false
|
|
}
|
|
k.cdc.MustUnmarshal(bz, &assetSupply)
|
|
return assetSupply, true
|
|
}
|
|
|
|
// SetAssetSupply updates an asset's supply
|
|
func (k Keeper) SetAssetSupply(ctx sdk.Context, supply types.AssetSupply, denom string) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.AssetSupplyPrefix)
|
|
store.Set([]byte(denom), k.cdc.MustMarshal(&supply))
|
|
}
|
|
|
|
// IterateAssetSupplies provides an iterator over all stored AssetSupplies.
|
|
func (k Keeper) IterateAssetSupplies(ctx sdk.Context, cb func(supply types.AssetSupply) (stop bool)) {
|
|
iterator := sdk.KVStorePrefixIterator(ctx.KVStore(k.key), types.AssetSupplyPrefix)
|
|
|
|
defer iterator.Close()
|
|
for ; iterator.Valid(); iterator.Next() {
|
|
var supply types.AssetSupply
|
|
k.cdc.MustUnmarshal(iterator.Value(), &supply)
|
|
|
|
if cb(supply) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// GetAllAssetSupplies returns all asset supplies from the store
|
|
func (k Keeper) GetAllAssetSupplies(ctx sdk.Context) (supplies types.AssetSupplies) {
|
|
k.IterateAssetSupplies(ctx, func(supply types.AssetSupply) bool {
|
|
supplies = append(supplies, supply)
|
|
return false
|
|
})
|
|
return
|
|
}
|
|
|
|
// GetPreviousBlockTime get the blocktime for the previous block
|
|
func (k Keeper) GetPreviousBlockTime(ctx sdk.Context) (blockTime time.Time, found bool) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.PreviousBlockTimeKey)
|
|
b := store.Get(types.PreviousBlockTimeKey)
|
|
if b == nil {
|
|
return time.Time{}, false
|
|
}
|
|
if err := blockTime.UnmarshalBinary(b); err != nil {
|
|
panic(err)
|
|
}
|
|
return blockTime, true
|
|
}
|
|
|
|
// SetPreviousBlockTime set the time of the previous block
|
|
func (k Keeper) SetPreviousBlockTime(ctx sdk.Context, blockTime time.Time) {
|
|
store := prefix.NewStore(ctx.KVStore(k.key), types.PreviousBlockTimeKey)
|
|
b, err := blockTime.MarshalBinary()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
store.Set(types.PreviousBlockTimeKey, b)
|
|
}
|