mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-12-26 16:25:21 +00:00
584 lines
22 KiB
Go
584 lines
22 KiB
Go
package keeper
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
errorsmod "cosmossdk.io/errors"
|
|
sdkmath "cosmossdk.io/math"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
|
|
|
|
"github.com/0glabs/0g-chain/x/auction/types"
|
|
)
|
|
|
|
// StartSurplusAuction starts a new surplus (forward) auction.
|
|
func (k Keeper) StartSurplusAuction(ctx sdk.Context, seller string, lot sdk.Coin, bidDenom string) (uint64, error) {
|
|
auction := types.NewSurplusAuction(
|
|
seller,
|
|
lot,
|
|
bidDenom,
|
|
types.DistantFuture,
|
|
)
|
|
|
|
// NOTE: for the duration of the auction the auction module account holds the lot
|
|
err := k.bankKeeper.SendCoinsFromModuleToModule(ctx, seller, types.ModuleName, sdk.NewCoins(lot))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
auctionID, err := k.StoreNewAuction(ctx, &auction)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
ctx.EventManager().EmitEvent(
|
|
sdk.NewEvent(
|
|
types.EventTypeAuctionStart,
|
|
sdk.NewAttribute(types.AttributeKeyAuctionID, fmt.Sprintf("%d", auctionID)),
|
|
sdk.NewAttribute(types.AttributeKeyAuctionType, auction.GetType()),
|
|
sdk.NewAttribute(types.AttributeKeyBid, auction.Bid.String()),
|
|
sdk.NewAttribute(types.AttributeKeyLot, auction.Lot.String()),
|
|
),
|
|
)
|
|
return auctionID, nil
|
|
}
|
|
|
|
// StartDebtAuction starts a new debt (reverse) auction.
|
|
func (k Keeper) StartDebtAuction(ctx sdk.Context, buyer string, bid sdk.Coin, initialLot sdk.Coin, debt sdk.Coin) (uint64, error) {
|
|
auction := types.NewDebtAuction(
|
|
buyer,
|
|
bid,
|
|
initialLot,
|
|
types.DistantFuture,
|
|
debt,
|
|
)
|
|
|
|
// This auction type mints coins at close. Need to check module account has minting privileges to avoid potential err in endblocker.
|
|
macc := k.accountKeeper.GetModuleAccount(ctx, buyer)
|
|
if !macc.HasPermission(authtypes.Minter) {
|
|
panic(fmt.Errorf("module '%s' does not have '%s' permission", buyer, authtypes.Minter))
|
|
}
|
|
|
|
// NOTE: for the duration of the auction the auction module account holds the debt
|
|
err := k.bankKeeper.SendCoinsFromModuleToModule(ctx, buyer, types.ModuleName, sdk.NewCoins(debt))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
auctionID, err := k.StoreNewAuction(ctx, &auction)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
ctx.EventManager().EmitEvent(
|
|
sdk.NewEvent(
|
|
types.EventTypeAuctionStart,
|
|
sdk.NewAttribute(types.AttributeKeyAuctionID, fmt.Sprintf("%d", auctionID)),
|
|
sdk.NewAttribute(types.AttributeKeyAuctionType, auction.GetType()),
|
|
sdk.NewAttribute(types.AttributeKeyBid, auction.Bid.String()),
|
|
sdk.NewAttribute(types.AttributeKeyLot, auction.Lot.String()),
|
|
),
|
|
)
|
|
return auctionID, nil
|
|
}
|
|
|
|
// StartCollateralAuction starts a new collateral (2-phase) auction.
|
|
func (k Keeper) StartCollateralAuction(
|
|
ctx sdk.Context, seller string, lot, maxBid sdk.Coin,
|
|
lotReturnAddrs []sdk.AccAddress, lotReturnWeights []sdkmath.Int, debt sdk.Coin,
|
|
) (uint64, error) {
|
|
weightedAddresses, err := types.NewWeightedAddresses(lotReturnAddrs, lotReturnWeights)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
auction := types.NewCollateralAuction(
|
|
seller,
|
|
lot,
|
|
types.DistantFuture,
|
|
maxBid,
|
|
weightedAddresses,
|
|
debt,
|
|
)
|
|
|
|
// NOTE: for the duration of the auction the auction module account holds the debt and the lot
|
|
err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, seller, types.ModuleName, sdk.NewCoins(lot))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, seller, types.ModuleName, sdk.NewCoins(debt))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
auctionID, err := k.StoreNewAuction(ctx, &auction)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
ctx.EventManager().EmitEvent(
|
|
sdk.NewEvent(
|
|
types.EventTypeAuctionStart,
|
|
sdk.NewAttribute(types.AttributeKeyAuctionID, fmt.Sprintf("%d", auctionID)),
|
|
sdk.NewAttribute(types.AttributeKeyAuctionType, auction.GetType()),
|
|
sdk.NewAttribute(types.AttributeKeyBid, auction.Bid.String()),
|
|
sdk.NewAttribute(types.AttributeKeyLot, auction.Lot.String()),
|
|
sdk.NewAttribute(types.AttributeKeyMaxBid, auction.MaxBid.String()),
|
|
),
|
|
)
|
|
return auctionID, nil
|
|
}
|
|
|
|
// PlaceBid places a bid on any auction.
|
|
func (k Keeper) PlaceBid(ctx sdk.Context, auctionID uint64, bidder sdk.AccAddress, newAmount sdk.Coin) error {
|
|
auction, found := k.GetAuction(ctx, auctionID)
|
|
if !found {
|
|
return errorsmod.Wrapf(types.ErrAuctionNotFound, "%d", auctionID)
|
|
}
|
|
|
|
// validation common to all auctions
|
|
if ctx.BlockTime().After(auction.GetEndTime()) {
|
|
return errorsmod.Wrapf(types.ErrAuctionHasExpired, "%d", auctionID)
|
|
}
|
|
|
|
// move coins and return updated auction
|
|
var (
|
|
err error
|
|
updatedAuction types.Auction
|
|
)
|
|
switch auctionType := auction.(type) {
|
|
case *types.SurplusAuction:
|
|
updatedAuction, err = k.PlaceBidSurplus(ctx, auctionType, bidder, newAmount)
|
|
case *types.DebtAuction:
|
|
updatedAuction, err = k.PlaceBidDebt(ctx, auctionType, bidder, newAmount)
|
|
case *types.CollateralAuction:
|
|
if !auctionType.IsReversePhase() {
|
|
updatedAuction, err = k.PlaceForwardBidCollateral(ctx, auctionType, bidder, newAmount)
|
|
} else {
|
|
updatedAuction, err = k.PlaceReverseBidCollateral(ctx, auctionType, bidder, newAmount)
|
|
}
|
|
default:
|
|
err = errorsmod.Wrap(types.ErrUnrecognizedAuctionType, auction.GetType())
|
|
}
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
k.SetAuction(ctx, updatedAuction)
|
|
|
|
return nil
|
|
}
|
|
|
|
// PlaceBidSurplus places a forward bid on a surplus auction, moving coins and returning the updated auction.
|
|
func (k Keeper) PlaceBidSurplus(ctx sdk.Context, auction *types.SurplusAuction, bidder sdk.AccAddress, bid sdk.Coin) (*types.SurplusAuction, error) {
|
|
// Validate new bid
|
|
if bid.Denom != auction.Bid.Denom {
|
|
return auction, errorsmod.Wrapf(types.ErrInvalidBidDenom, "%s ≠ %s", bid.Denom, auction.Bid.Denom)
|
|
}
|
|
minNewBidAmt := auction.Bid.Amount.Add( // new bids must be some % greater than old bid, and at least 1 larger to avoid replacing an old bid at no cost
|
|
sdk.MaxInt(
|
|
sdkmath.NewInt(1),
|
|
sdk.NewDecFromInt(auction.Bid.Amount).Mul(k.GetParams(ctx).IncrementSurplus).RoundInt(),
|
|
),
|
|
)
|
|
if bid.Amount.LT(minNewBidAmt) {
|
|
return auction, errorsmod.Wrapf(types.ErrBidTooSmall, "%s < %s%s", bid, minNewBidAmt, auction.Bid.Denom)
|
|
}
|
|
|
|
// New bidder pays back old bidder
|
|
// Catch edge cases of a bidder replacing their own bid, or the amount being zero (sending zero coins produces meaningless send events).
|
|
if !bidder.Equals(auction.Bidder) && !auction.Bid.IsZero() { // bidder isn't same as before AND previous auction bid must exist
|
|
err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, bidder, types.ModuleName, sdk.NewCoins(auction.Bid))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, auction.Bidder, sdk.NewCoins(auction.Bid))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
}
|
|
|
|
err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, bidder, auction.Initiator, sdk.NewCoins(bid.Sub(auction.Bid)))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
|
|
// Received bid amount is burned from the module account
|
|
err = k.bankKeeper.BurnCoins(ctx, auction.Initiator, sdk.NewCoins(bid.Sub(auction.Bid)))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
|
|
// Update Auction
|
|
auction.Bidder = bidder
|
|
auction.Bid = bid
|
|
if !auction.HasReceivedBids {
|
|
auction.MaxEndTime = ctx.BlockTime().Add(k.GetParams(ctx).MaxAuctionDuration) // set maximum ending time on receipt of first bid
|
|
auction.HasReceivedBids = true
|
|
}
|
|
auction.EndTime = earliestTime(ctx.BlockTime().Add(k.GetParams(ctx).ForwardBidDuration), auction.MaxEndTime) // increment timeout, up to MaxEndTime
|
|
|
|
ctx.EventManager().EmitEvent(
|
|
sdk.NewEvent(
|
|
types.EventTypeAuctionBid,
|
|
sdk.NewAttribute(types.AttributeKeyAuctionID, fmt.Sprintf("%d", auction.ID)),
|
|
sdk.NewAttribute(types.AttributeKeyBidder, auction.Bidder.String()),
|
|
sdk.NewAttribute(types.AttributeKeyBid, auction.Bid.String()),
|
|
sdk.NewAttribute(types.AttributeKeyEndTime, fmt.Sprintf("%d", auction.EndTime.Unix())),
|
|
),
|
|
)
|
|
|
|
return auction, nil
|
|
}
|
|
|
|
// PlaceForwardBidCollateral places a forward bid on a collateral auction, moving coins and returning the updated auction.
|
|
func (k Keeper) PlaceForwardBidCollateral(ctx sdk.Context, auction *types.CollateralAuction, bidder sdk.AccAddress, bid sdk.Coin) (*types.CollateralAuction, error) {
|
|
// Validate new bid
|
|
if bid.Denom != auction.Bid.Denom {
|
|
return auction, errorsmod.Wrapf(types.ErrInvalidBidDenom, "%s ≠ %s", bid.Denom, auction.Bid.Denom)
|
|
}
|
|
if auction.IsReversePhase() {
|
|
panic("cannot place reverse bid on auction in forward phase")
|
|
}
|
|
minNewBidAmt := auction.Bid.Amount.Add( // new bids must be some % greater than old bid, and at least 1 larger to avoid replacing an old bid at no cost
|
|
sdk.MaxInt(
|
|
sdkmath.NewInt(1),
|
|
sdk.NewDecFromInt(auction.Bid.Amount).Mul(k.GetParams(ctx).IncrementCollateral).RoundInt(),
|
|
),
|
|
)
|
|
minNewBidAmt = sdk.MinInt(minNewBidAmt, auction.MaxBid.Amount) // allow new bids to hit MaxBid even though it may be less than the increment %
|
|
if bid.Amount.LT(minNewBidAmt) {
|
|
return auction, errorsmod.Wrapf(types.ErrBidTooSmall, "%s < %s%s", bid, minNewBidAmt, auction.Bid.Denom)
|
|
}
|
|
if auction.MaxBid.IsLT(bid) {
|
|
return auction, errorsmod.Wrapf(types.ErrBidTooLarge, "%s > %s", bid, auction.MaxBid)
|
|
}
|
|
|
|
// New bidder pays back old bidder
|
|
// Catch edge cases of a bidder replacing their own bid, and the amount being zero (sending zero coins produces meaningless send events).
|
|
if !bidder.Equals(auction.Bidder) && !auction.Bid.IsZero() {
|
|
err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, bidder, types.ModuleName, sdk.NewCoins(auction.Bid))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, auction.Bidder, sdk.NewCoins(auction.Bid))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
}
|
|
// Increase in bid sent to auction initiator
|
|
bidIncrement := bid.Sub(auction.Bid)
|
|
err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, bidder, auction.Initiator, sdk.NewCoins(bidIncrement))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
// Debt coins are sent to liquidator (until there is no CorrespondingDebt left). Amount sent is equal to bidIncrement (or whatever is left if < bidIncrement).
|
|
if auction.CorrespondingDebt.IsPositive() {
|
|
|
|
debtAmountToReturn := sdk.MinInt(bidIncrement.Amount, auction.CorrespondingDebt.Amount)
|
|
debtToReturn := sdk.NewCoin(auction.CorrespondingDebt.Denom, debtAmountToReturn)
|
|
|
|
err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, auction.Initiator, sdk.NewCoins(debtToReturn))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
auction.CorrespondingDebt = auction.CorrespondingDebt.Sub(debtToReturn) // debtToReturn will always be ≤ auction.CorrespondingDebt from the MinInt above
|
|
}
|
|
|
|
// Update Auction
|
|
auction.Bidder = bidder
|
|
auction.Bid = bid
|
|
if !auction.HasReceivedBids {
|
|
auction.MaxEndTime = ctx.BlockTime().Add(k.GetParams(ctx).MaxAuctionDuration) // set maximum ending time on receipt of first bid
|
|
auction.HasReceivedBids = true
|
|
}
|
|
|
|
// If this forward bid converts this to a reverse, increase timeout with ReverseBidDuration
|
|
if auction.IsReversePhase() {
|
|
auction.EndTime = earliestTime(ctx.BlockTime().Add(k.GetParams(ctx).ReverseBidDuration), auction.MaxEndTime) // increment timeout, up to MaxEndTime
|
|
} else {
|
|
auction.EndTime = earliestTime(ctx.BlockTime().Add(k.GetParams(ctx).ForwardBidDuration), auction.MaxEndTime) // increment timeout, up to MaxEndTime
|
|
}
|
|
|
|
ctx.EventManager().EmitEvent(
|
|
sdk.NewEvent(
|
|
types.EventTypeAuctionBid,
|
|
sdk.NewAttribute(types.AttributeKeyAuctionID, fmt.Sprintf("%d", auction.ID)),
|
|
sdk.NewAttribute(types.AttributeKeyBidder, auction.Bidder.String()),
|
|
sdk.NewAttribute(types.AttributeKeyBid, auction.Bid.String()),
|
|
sdk.NewAttribute(types.AttributeKeyEndTime, fmt.Sprintf("%d", auction.EndTime.Unix())),
|
|
),
|
|
)
|
|
|
|
return auction, nil
|
|
}
|
|
|
|
// PlaceReverseBidCollateral places a reverse bid on a collateral auction, moving coins and returning the updated auction.
|
|
func (k Keeper) PlaceReverseBidCollateral(ctx sdk.Context, auction *types.CollateralAuction, bidder sdk.AccAddress, lot sdk.Coin) (*types.CollateralAuction, error) {
|
|
// Validate new bid
|
|
if lot.Denom != auction.Lot.Denom {
|
|
return auction, errorsmod.Wrapf(types.ErrInvalidLotDenom, "%s ≠ %s", lot.Denom, auction.Lot.Denom)
|
|
}
|
|
if !auction.IsReversePhase() {
|
|
panic("cannot place forward bid on auction in reverse phase")
|
|
}
|
|
maxNewLotAmt := auction.Lot.Amount.Sub( // new lot must be some % less than old lot, and at least 1 smaller to avoid replacing an old bid at no cost
|
|
sdk.MaxInt(
|
|
sdkmath.NewInt(1),
|
|
sdk.NewDecFromInt(auction.Lot.Amount).Mul(k.GetParams(ctx).IncrementCollateral).RoundInt(),
|
|
),
|
|
)
|
|
if lot.Amount.GT(maxNewLotAmt) {
|
|
return auction, errorsmod.Wrapf(types.ErrLotTooLarge, "%s > %s%s", lot, maxNewLotAmt, auction.Lot.Denom)
|
|
}
|
|
if lot.IsNegative() {
|
|
return auction, errorsmod.Wrapf(types.ErrLotTooSmall, "%s < 0%s", lot, auction.Lot.Denom)
|
|
}
|
|
|
|
// New bidder pays back old bidder
|
|
// Catch edge cases of a bidder replacing their own bid
|
|
if !bidder.Equals(auction.Bidder) {
|
|
err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, bidder, types.ModuleName, sdk.NewCoins(auction.Bid))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, auction.Bidder, sdk.NewCoins(auction.Bid))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
}
|
|
|
|
// Decrease in lot is sent to weighted addresses (normally the CDP depositors)
|
|
// Note: splitting an integer amount across weighted buckets results in small errors.
|
|
lotPayouts, err := splitCoinIntoWeightedBuckets(auction.Lot.Sub(lot), auction.LotReturns.Weights)
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
for i, payout := range lotPayouts {
|
|
// if the payout amount is 0, don't send 0 coins
|
|
if !payout.IsPositive() {
|
|
continue
|
|
}
|
|
err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, auction.LotReturns.Addresses[i], sdk.NewCoins(payout))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
}
|
|
|
|
// Update Auction
|
|
auction.Bidder = bidder
|
|
auction.Lot = lot
|
|
if !auction.HasReceivedBids {
|
|
auction.MaxEndTime = ctx.BlockTime().Add(k.GetParams(ctx).MaxAuctionDuration) // set maximum ending time on receipt of first bid
|
|
auction.HasReceivedBids = true
|
|
}
|
|
auction.EndTime = earliestTime(ctx.BlockTime().Add(k.GetParams(ctx).ReverseBidDuration), auction.MaxEndTime) // increment timeout, up to MaxEndTime
|
|
|
|
ctx.EventManager().EmitEvent(
|
|
sdk.NewEvent(
|
|
types.EventTypeAuctionBid,
|
|
sdk.NewAttribute(types.AttributeKeyAuctionID, fmt.Sprintf("%d", auction.ID)),
|
|
sdk.NewAttribute(types.AttributeKeyBidder, auction.Bidder.String()),
|
|
sdk.NewAttribute(types.AttributeKeyLot, auction.Lot.String()),
|
|
sdk.NewAttribute(types.AttributeKeyEndTime, fmt.Sprintf("%d", auction.EndTime.Unix())),
|
|
),
|
|
)
|
|
|
|
return auction, nil
|
|
}
|
|
|
|
// PlaceBidDebt places a reverse bid on a debt auction, moving coins and returning the updated auction.
|
|
func (k Keeper) PlaceBidDebt(ctx sdk.Context, auction *types.DebtAuction, bidder sdk.AccAddress, lot sdk.Coin) (*types.DebtAuction, error) {
|
|
// Validate new bid
|
|
if lot.Denom != auction.Lot.Denom {
|
|
return auction, errorsmod.Wrapf(types.ErrInvalidLotDenom, "%s ≠ %s", lot.Denom, auction.Lot.Denom)
|
|
}
|
|
maxNewLotAmt := auction.Lot.Amount.Sub( // new lot must be some % less than old lot, and at least 1 smaller to avoid replacing an old bid at no cost
|
|
sdk.MaxInt(
|
|
sdkmath.NewInt(1),
|
|
sdk.NewDecFromInt(auction.Lot.Amount).Mul(k.GetParams(ctx).IncrementDebt).RoundInt(),
|
|
),
|
|
)
|
|
if lot.Amount.GT(maxNewLotAmt) {
|
|
return auction, errorsmod.Wrapf(types.ErrLotTooLarge, "%s > %s%s", lot, maxNewLotAmt, auction.Lot.Denom)
|
|
}
|
|
if lot.IsNegative() {
|
|
return auction, errorsmod.Wrapf(types.ErrLotTooSmall, "%s ≤ %s%s", lot, sdk.ZeroInt(), auction.Lot.Denom)
|
|
}
|
|
|
|
// New bidder pays back old bidder
|
|
// Catch edge cases of a bidder replacing their own bid
|
|
if !bidder.Equals(auction.Bidder) {
|
|
// Bidder sends coins to module
|
|
err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, bidder, types.ModuleName, sdk.NewCoins(auction.Bid))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
// Coins are sent from module to old bidder
|
|
oldBidder := auction.Bidder
|
|
if oldBidder.Equals(authtypes.NewModuleAddress(auction.Initiator)) { // First bid on auction (where there is no previous bidder)
|
|
err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, auction.Initiator, sdk.NewCoins(auction.Bid))
|
|
} else { // Second and later bids on auction (where previous bidder is a user account)
|
|
err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, oldBidder, sdk.NewCoins(auction.Bid))
|
|
}
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
}
|
|
|
|
// Debt coins are sent to liquidator the first time a bid is placed. Amount sent is equal to min of Bid and amount of debt.
|
|
if auction.Bidder.Equals(authtypes.NewModuleAddress(auction.Initiator)) {
|
|
// Handle debt coins for first bid
|
|
debtAmountToReturn := sdk.MinInt(auction.Bid.Amount, auction.CorrespondingDebt.Amount)
|
|
debtToReturn := sdk.NewCoin(auction.CorrespondingDebt.Denom, debtAmountToReturn)
|
|
|
|
err := k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, auction.Initiator, sdk.NewCoins(debtToReturn))
|
|
if err != nil {
|
|
return auction, err
|
|
}
|
|
auction.CorrespondingDebt = auction.CorrespondingDebt.Sub(debtToReturn) // debtToReturn will always be ≤ auction.CorrespondingDebt from the MinInt above
|
|
}
|
|
|
|
// Update Auction
|
|
auction.Bidder = bidder
|
|
auction.Lot = lot
|
|
if !auction.HasReceivedBids {
|
|
auction.MaxEndTime = ctx.BlockTime().Add(k.GetParams(ctx).MaxAuctionDuration) // set maximum ending time on receipt of first bid
|
|
auction.HasReceivedBids = true
|
|
}
|
|
auction.EndTime = earliestTime(ctx.BlockTime().Add(k.GetParams(ctx).ForwardBidDuration), auction.MaxEndTime) // increment timeout, up to MaxEndTime
|
|
|
|
ctx.EventManager().EmitEvent(
|
|
sdk.NewEvent(
|
|
types.EventTypeAuctionBid,
|
|
sdk.NewAttribute(types.AttributeKeyAuctionID, fmt.Sprintf("%d", auction.ID)),
|
|
sdk.NewAttribute(types.AttributeKeyBidder, auction.Bidder.String()),
|
|
sdk.NewAttribute(types.AttributeKeyLot, auction.Lot.String()),
|
|
sdk.NewAttribute(types.AttributeKeyEndTime, fmt.Sprintf("%d", auction.EndTime.Unix())),
|
|
),
|
|
)
|
|
|
|
return auction, nil
|
|
}
|
|
|
|
// CloseAuction closes an auction and distributes funds to the highest bidder.
|
|
func (k Keeper) CloseAuction(ctx sdk.Context, auctionID uint64) error {
|
|
auction, found := k.GetAuction(ctx, auctionID)
|
|
if !found {
|
|
return errorsmod.Wrapf(types.ErrAuctionNotFound, "%d", auctionID)
|
|
}
|
|
|
|
if ctx.BlockTime().Before(auction.GetEndTime()) {
|
|
return errorsmod.Wrapf(types.ErrAuctionHasNotExpired, "block time %s, auction end time %s", ctx.BlockTime().UTC(), auction.GetEndTime().UTC())
|
|
}
|
|
|
|
// payout to the last bidder
|
|
var err error
|
|
switch auc := auction.(type) {
|
|
case *types.SurplusAuction:
|
|
err = k.PayoutSurplusAuction(ctx, auc)
|
|
case *types.DebtAuction:
|
|
err = k.PayoutDebtAuction(ctx, auc)
|
|
case *types.CollateralAuction:
|
|
err = k.PayoutCollateralAuction(ctx, auc)
|
|
default:
|
|
err = errorsmod.Wrap(types.ErrUnrecognizedAuctionType, auc.GetType())
|
|
}
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
k.DeleteAuction(ctx, auctionID)
|
|
|
|
ctx.EventManager().EmitEvent(
|
|
sdk.NewEvent(
|
|
types.EventTypeAuctionClose,
|
|
sdk.NewAttribute(types.AttributeKeyAuctionID, fmt.Sprintf("%d", auctionID)),
|
|
sdk.NewAttribute(types.AttributeKeyCloseBlock, fmt.Sprintf("%d", ctx.BlockHeight())),
|
|
),
|
|
)
|
|
return nil
|
|
}
|
|
|
|
// PayoutDebtAuction pays out the proceeds for a debt auction, first minting the coins.
|
|
func (k Keeper) PayoutDebtAuction(ctx sdk.Context, auction *types.DebtAuction) error {
|
|
// create the coins that are needed to pay off the debt
|
|
err := k.bankKeeper.MintCoins(ctx, auction.Initiator, sdk.NewCoins(auction.Lot))
|
|
if err != nil {
|
|
panic(fmt.Errorf("could not mint coins: %w", err))
|
|
}
|
|
// send the new coins from the initiator module to the bidder
|
|
err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, auction.Initiator, auction.Bidder, sdk.NewCoins(auction.Lot))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// if there is remaining debt, return it to the calling module to manage
|
|
if !auction.CorrespondingDebt.IsPositive() {
|
|
return nil
|
|
}
|
|
|
|
return k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, auction.Initiator, sdk.NewCoins(auction.CorrespondingDebt))
|
|
}
|
|
|
|
// PayoutSurplusAuction pays out the proceeds for a surplus auction.
|
|
func (k Keeper) PayoutSurplusAuction(ctx sdk.Context, auction *types.SurplusAuction) error {
|
|
// Send the tokens from the auction module account where they are being managed to the bidder who won the auction
|
|
return k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, auction.Bidder, sdk.NewCoins(auction.Lot))
|
|
}
|
|
|
|
// PayoutCollateralAuction pays out the proceeds for a collateral auction.
|
|
func (k Keeper) PayoutCollateralAuction(ctx sdk.Context, auction *types.CollateralAuction) error {
|
|
// Send the tokens from the auction module account where they are being managed to the bidder who won the auction
|
|
err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, auction.Bidder, sdk.NewCoins(auction.Lot))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// if there is remaining debt after the auction, send it back to the initiating module for management
|
|
if !auction.CorrespondingDebt.IsPositive() {
|
|
return nil
|
|
}
|
|
|
|
return k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, auction.Initiator, sdk.NewCoins(auction.CorrespondingDebt))
|
|
}
|
|
|
|
// CloseExpiredAuctions iterates over all the auctions stored by until the current
|
|
// block timestamp and that are past (or at) their ending times and closes them,
|
|
// paying out to the highest bidder.
|
|
func (k Keeper) CloseExpiredAuctions(ctx sdk.Context) error {
|
|
var err error
|
|
k.IterateAuctionsByTime(ctx, ctx.BlockTime(), func(id uint64) (stop bool) {
|
|
err = k.CloseAuction(ctx, id)
|
|
if err != nil && !errors.Is(err, types.ErrAuctionNotFound) {
|
|
// stop iteration
|
|
return true
|
|
}
|
|
// reset error in case the last element had an ErrAuctionNotFound
|
|
err = nil
|
|
return false
|
|
})
|
|
|
|
return err
|
|
}
|
|
|
|
// earliestTime returns the earliest of two times.
|
|
func earliestTime(t1, t2 time.Time) time.Time {
|
|
if t1.Before(t2) {
|
|
return t1
|
|
}
|
|
return t2 // also returned if times are equal
|
|
}
|
|
|
|
// splitCoinIntoWeightedBuckets divides up some amount of coins according to some weights.
|
|
func splitCoinIntoWeightedBuckets(coin sdk.Coin, buckets []sdkmath.Int) ([]sdk.Coin, error) {
|
|
amounts := splitIntIntoWeightedBuckets(coin.Amount, buckets)
|
|
result := make([]sdk.Coin, len(amounts))
|
|
for i, a := range amounts {
|
|
result[i] = sdk.NewCoin(coin.Denom, a)
|
|
}
|
|
return result, nil
|
|
}
|