gpu-compute-chain/x/colinearcore/keeper/auction_state.go

114 lines
3.2 KiB
Go
Raw Normal View History

2022-08-31 15:40:28 -07:00
package keeper
import (
2022-09-06 15:18:09 -07:00
"colinear/x/colinearcore/math"
"colinear/x/colinearcore/memdb"
"colinear/x/colinearcore/types"
"log"
"math/big"
2022-09-02 14:03:03 -07:00
"time"
2022-08-31 15:40:28 -07:00
sdk "github.com/cosmos/cosmos-sdk/types"
2022-08-31 15:40:28 -07:00
"github.com/pkg/errors"
)
func (k Keeper) AuctionIsExpired(ctx sdk.Context, auctionId string) (bool, error) {
2022-08-31 15:40:28 -07:00
auction, found := k.GetAuction(ctx, auctionId)
// make sure the auction exists on-chain
if !found {
return true, errors.Errorf("auction %s not found", auctionId)
}
return uint64(ctx.BlockHeight()) >= auction.Deadline, nil
}
func (k Keeper) FinalizeExpiredAuctions(ctx sdk.Context) {
2022-08-31 15:40:28 -07:00
memdb.BidDB.ForEachAuction(func(auctionId string) error {
auction, found := k.GetAuction(ctx, auctionId)
// make sure the auction exists on-chain
if !found {
2022-09-02 14:03:03 -07:00
return errors.Errorf("auction %s not found", auctionId)
2022-08-31 15:40:28 -07:00
}
if uint64(ctx.BlockHeight()) >= auction.Deadline {
2022-08-31 15:40:28 -07:00
var err error
auction.Best, err = memdb.BidDB.GetLowestBid(auctionId)
2022-08-31 15:40:28 -07:00
if err != nil {
return errors.Errorf("could not get highest bid for auction %s: %s", auctionId, err)
}
2022-09-05 15:17:55 -07:00
// Remaining Unpaid: Full bid amount
2022-09-02 14:03:03 -07:00
auction.Remaining = auction.Best.Amount
// clear auction
if err := memdb.BidDB.ClearAuction(auctionId); err != nil {
return errors.Errorf("failed to clear auction from memcache: %s", err)
}
// pay out unpaid remainder to auction creator
ceiling := new(big.Int)
ceiling.SetString(auction.Ceiling, 10)
lowestBidAmt := new(big.Int)
lowestBidAmt.SetString(auction.Best.Amount, 10)
// only pay out if there is a difference
if ceiling.Cmp(lowestBidAmt) == 1 {
amtRemaining := new(big.Int)
amtRemaining.Sub(ceiling, lowestBidAmt)
coins := sdk.NewCoins(sdk.NewCoin(
auction.Denom,
sdk.NewIntFromBigInt(amtRemaining),
))
recipAddr, err := sdk.AccAddressFromBech32(auction.Owner)
if err != nil {
return errors.Errorf("failed to parse address %s", auction.Owner)
}
if err := k.bank.SendCoinsFromModuleToAccount(ctx, types.ModuleName, recipAddr, coins); err != nil {
log.Printf("Failed to send coins from module: %s\n", err)
// log.Fatalf("Failed to send coins from module: %s\n", err)
}
}
// lease period starts now
auction.LeaseStart = uint64(ctx.BlockTime().Unix())
// end auction
k.SetAuction(ctx, auction)
2022-08-31 15:40:28 -07:00
}
return nil
})
}
2022-09-01 12:13:17 -07:00
func (k *Keeper) PayAuctionAmountDue(ctx sdk.Context, auctionId string) error {
2022-09-02 14:03:03 -07:00
auction, found := k.GetAuction(ctx, auctionId)
if !found {
return errors.Errorf("auction %s not found", auctionId)
}
blockTime := ctx.BlockTime()
deadline := time.Unix(int64(auction.Deadline), 0)
2022-09-01 12:13:17 -07:00
2022-09-02 14:03:03 -07:00
if blockTime.After(deadline) {
return nil
} else {
amtTotal := new(big.Int)
amtTotal.SetString(auction.Best.Amount, 10)
amtRemaining := new(big.Int)
amtTotal.SetString(auction.Remaining, 10)
amt, err := math.CalcAmountVestableLinear(
amtTotal,
amtRemaining,
ctx.BlockTime(),
time.Unix(int64(auction.LeaseStart), 0),
time.Unix(int64(auction.LeaseEnd), 0),
)
if err != nil {
return err
}
coins := sdk.NewCoins(sdk.NewCoin(auction.Denom, sdk.NewIntFromBigInt(amt)))
err = k.bank.SendCoinsFromModuleToAccount(ctx, "colinear", sdk.AccAddress(auction.Best.Owner), coins)
2022-09-02 14:03:03 -07:00
return err
}
2022-09-01 12:13:17 -07:00
}