mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-11-15 04:25:27 +00:00
592 lines
19 KiB
Go
592 lines
19 KiB
Go
package keeper_test
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
sdkmath "cosmossdk.io/math"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
|
|
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
|
|
|
|
"github.com/0glabs/0g-chain/app"
|
|
"github.com/0glabs/0g-chain/x/auction/types"
|
|
)
|
|
|
|
type AuctionType int
|
|
|
|
const (
|
|
Invalid AuctionType = 0
|
|
Surplus AuctionType = 1
|
|
Debt AuctionType = 2
|
|
Collateral AuctionType = 3
|
|
)
|
|
|
|
func TestAuctionBidding(t *testing.T) {
|
|
config := sdk.GetConfig()
|
|
app.SetBech32AddressPrefixes(config)
|
|
|
|
someTime := time.Date(0o001, time.January, 1, 0, 0, 0, 0, time.UTC)
|
|
|
|
_, addrs := app.GeneratePrivKeyAddressPairs(5)
|
|
buyer := addrs[0]
|
|
secondBuyer := addrs[1]
|
|
modName := "liquidator"
|
|
collateralAddrs := addrs[2:]
|
|
collateralWeights := is(30, 20, 10)
|
|
|
|
initialBalance := cs(c("token1", 1000), c("token2", 1000))
|
|
|
|
type auctionArgs struct {
|
|
auctionType AuctionType
|
|
seller string
|
|
lot sdk.Coin
|
|
bid sdk.Coin
|
|
debt sdk.Coin
|
|
addresses []sdk.AccAddress
|
|
weights []sdkmath.Int
|
|
}
|
|
|
|
type bidArgs struct {
|
|
bidder sdk.AccAddress
|
|
amount sdk.Coin
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
auctionArgs auctionArgs
|
|
setupBids []bidArgs
|
|
bidArgs bidArgs
|
|
expectedError error
|
|
expectedEndTime time.Time
|
|
expectedBidder sdk.AccAddress
|
|
expectedBid sdk.Coin
|
|
expectPass bool
|
|
expectPanic bool
|
|
}{
|
|
{
|
|
"basic: auction doesn't exist",
|
|
auctionArgs{Surplus, "", c("token1", 1), c("token2", 1), sdk.Coin{}, []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
nil,
|
|
bidArgs{buyer, c("token2", 10)},
|
|
types.ErrAuctionNotFound,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
buyer,
|
|
c("token2", 10),
|
|
false,
|
|
true,
|
|
},
|
|
{
|
|
"basic: closed auction",
|
|
auctionArgs{Surplus, modName, c("token1", 100), c("token2", 10), sdk.Coin{}, []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
nil,
|
|
bidArgs{buyer, c("token2", 10)},
|
|
types.ErrAuctionHasExpired,
|
|
types.DistantFuture,
|
|
nil,
|
|
c("token2", 0),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
// This is the first bid on an auction with NO bids
|
|
"surplus: normal",
|
|
auctionArgs{Surplus, modName, c("token1", 100), c("token2", 10), sdk.Coin{}, []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
nil,
|
|
bidArgs{buyer, c("token2", 10)},
|
|
nil,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
buyer,
|
|
c("token2", 10),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"surplus: second bidder",
|
|
auctionArgs{Surplus, modName, c("token1", 100), c("token2", 10), sdk.Coin{}, []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
[]bidArgs{{buyer, c("token2", 10)}},
|
|
bidArgs{secondBuyer, c("token2", 11)},
|
|
nil,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
secondBuyer,
|
|
c("token2", 11),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"surplus: invalid bid denom",
|
|
auctionArgs{Surplus, modName, c("token1", 100), c("token2", 10), sdk.Coin{}, []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
nil,
|
|
bidArgs{buyer, c("badtoken", 10)},
|
|
types.ErrInvalidBidDenom,
|
|
types.DistantFuture,
|
|
nil, // surplus auctions are created with initial bidder as a nil address
|
|
c("token2", 0),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"surplus: invalid bid (less than)",
|
|
auctionArgs{Surplus, modName, c("token1", 100), c("token2", 0), sdk.Coin{}, []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
[]bidArgs{{buyer, c("token2", 100)}},
|
|
bidArgs{buyer, c("token2", 99)},
|
|
types.ErrBidTooSmall,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
buyer,
|
|
c("token2", 100),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"surplus: invalid bid (equal)",
|
|
auctionArgs{Surplus, modName, c("token1", 100), c("token2", 0), sdk.Coin{}, []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
nil,
|
|
bidArgs{buyer, c("token2", 0)}, // min bid is technically 0 at default 5%, but it's capped at 1
|
|
types.ErrBidTooSmall,
|
|
types.DistantFuture,
|
|
nil, // surplus auctions are created with initial bidder as a nil address
|
|
c("token2", 0),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"surplus: invalid bid (less than min increment)",
|
|
auctionArgs{Surplus, modName, c("token1", 100), c("token2", 0), sdk.Coin{}, []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
[]bidArgs{{buyer, c("token2", 100)}},
|
|
bidArgs{buyer, c("token2", 104)}, // min bid is 105 at default 5%
|
|
types.ErrBidTooSmall,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
buyer,
|
|
c("token2", 100),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"debt: normal",
|
|
auctionArgs{Debt, modName, c("token1", 20), c("token2", 100), c("debt", 100), []sdk.AccAddress{}, []sdkmath.Int{}}, // initial bid, lot
|
|
nil,
|
|
bidArgs{buyer, c("token1", 10)},
|
|
nil,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
buyer,
|
|
c("token2", 100),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"debt: second bidder",
|
|
auctionArgs{Debt, modName, c("token1", 20), c("token2", 100), c("debt", 100), []sdk.AccAddress{}, []sdkmath.Int{}}, // initial bid, lot
|
|
[]bidArgs{{buyer, c("token1", 10)}},
|
|
bidArgs{secondBuyer, c("token1", 9)},
|
|
nil,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
secondBuyer,
|
|
c("token2", 100),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"debt: invalid lot denom",
|
|
auctionArgs{Debt, modName, c("token1", 20), c("token2", 100), c("debt", 100), []sdk.AccAddress{}, []sdkmath.Int{}}, // initial bid, lot
|
|
nil,
|
|
bidArgs{buyer, c("badtoken", 10)},
|
|
types.ErrInvalidLotDenom,
|
|
types.DistantFuture,
|
|
authtypes.NewModuleAddress(modName),
|
|
c("token2", 100),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"debt: invalid lot size (larger)",
|
|
auctionArgs{Debt, modName, c("token1", 20), c("token2", 100), c("debt", 100), []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
nil,
|
|
bidArgs{buyer, c("token1", 21)},
|
|
types.ErrLotTooLarge,
|
|
types.DistantFuture,
|
|
authtypes.NewModuleAddress(modName),
|
|
c("token2", 100),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"debt: invalid lot size (equal)",
|
|
auctionArgs{Debt, modName, c("token1", 20), c("token2", 100), c("debt", 100), []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
nil,
|
|
bidArgs{buyer, c("token1", 20)},
|
|
types.ErrLotTooLarge,
|
|
types.DistantFuture,
|
|
authtypes.NewModuleAddress(modName),
|
|
c("token2", 100),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"debt: invalid lot size (larger than min increment)",
|
|
auctionArgs{Debt, modName, c("token1", 60), c("token2", 100), c("debt", 100), []sdk.AccAddress{}, []sdkmath.Int{}},
|
|
nil,
|
|
bidArgs{buyer, c("token1", 58)}, // max lot at default 5% is 57
|
|
types.ErrLotTooLarge,
|
|
types.DistantFuture,
|
|
authtypes.NewModuleAddress(modName),
|
|
c("token2", 100),
|
|
false, false,
|
|
},
|
|
{
|
|
"collateral [forward]: normal",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 100), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
nil,
|
|
bidArgs{buyer, c("token2", 10)},
|
|
nil,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
buyer,
|
|
c("token2", 10),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [forward]: second bidder",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 100), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 10)}},
|
|
bidArgs{secondBuyer, c("token2", 11)},
|
|
nil,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
secondBuyer,
|
|
c("token2", 11),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [forward]: convert to reverse (reach maxBid)",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 100), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 10)}},
|
|
bidArgs{secondBuyer, c("token2", 100)},
|
|
nil,
|
|
someTime.Add(types.DefaultReverseBidDuration),
|
|
secondBuyer,
|
|
c("token2", 100),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [forward]: invalid bid denom",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 100), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
nil,
|
|
bidArgs{buyer, c("badtoken", 10)},
|
|
types.ErrInvalidBidDenom,
|
|
types.DistantFuture,
|
|
nil,
|
|
c("token2", 0),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [forward]: invalid bid size (smaller)",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 100), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 10)}},
|
|
bidArgs{buyer, c("token2", 9)},
|
|
types.ErrBidTooSmall,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
buyer,
|
|
c("token2", 10),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [forward]: invalid bid size (equal)",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 100), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
nil,
|
|
bidArgs{buyer, c("token2", 0)},
|
|
types.ErrBidTooSmall,
|
|
types.DistantFuture,
|
|
nil,
|
|
c("token2", 0),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [forward]: invalid bid size (less than min increment)",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 100), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 50)}},
|
|
bidArgs{buyer, c("token2", 51)},
|
|
types.ErrBidTooSmall,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
buyer,
|
|
c("token2", 50),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [forward]: less than min increment but equal to maxBid",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 100), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 99)}},
|
|
bidArgs{buyer, c("token2", 100)}, // min bid at default 5% is 104
|
|
nil,
|
|
someTime.Add(types.DefaultReverseBidDuration), // Converts to a reverse bid when max reached
|
|
buyer,
|
|
c("token2", 100),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [forward]: invalid bid size (greater than max)",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 100), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
nil,
|
|
bidArgs{buyer, c("token2", 101)},
|
|
types.ErrBidTooLarge,
|
|
types.DistantFuture,
|
|
nil,
|
|
c("token2", 0),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [forward]: bidder replaces previous bid with only funds for difference",
|
|
auctionArgs{Collateral, modName, c("token1", 1000), c("token2", 2000), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 900)}},
|
|
bidArgs{buyer, c("token2", 1000)}, // buyer only has enough to cover the increase from previous bid
|
|
nil,
|
|
someTime.Add(types.DefaultForwardBidDuration),
|
|
buyer,
|
|
c("token2", 1000),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [reverse]: normal",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 50), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 50)}}, // put auction into reverse phase
|
|
bidArgs{buyer, c("token1", 15)},
|
|
nil,
|
|
someTime.Add(types.DefaultReverseBidDuration),
|
|
buyer,
|
|
c("token2", 50),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [reverse]: second bidder",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 50), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 50)}, {buyer, c("token1", 15)}}, // put auction into reverse phase, and add a reverse phase bid
|
|
bidArgs{secondBuyer, c("token1", 14)},
|
|
nil,
|
|
someTime.Add(types.DefaultReverseBidDuration),
|
|
secondBuyer,
|
|
c("token2", 50),
|
|
true,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [reverse]: invalid lot denom",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 50), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 50)}}, // put auction into reverse phase
|
|
bidArgs{buyer, c("badtoken", 15)},
|
|
types.ErrInvalidLotDenom,
|
|
someTime.Add(types.DefaultReverseBidDuration),
|
|
buyer,
|
|
c("token2", 50),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [reverse]: invalid lot size (greater)",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 50), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 50)}}, // put auction into reverse phase
|
|
bidArgs{buyer, c("token1", 21)},
|
|
types.ErrLotTooLarge,
|
|
someTime.Add(types.DefaultReverseBidDuration),
|
|
buyer,
|
|
c("token2", 50),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [reverse]: invalid lot size (equal)",
|
|
auctionArgs{Collateral, modName, c("token1", 20), c("token2", 50), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 50)}}, // put auction into reverse phase
|
|
bidArgs{buyer, c("token1", 20)},
|
|
types.ErrLotTooLarge,
|
|
someTime.Add(types.DefaultReverseBidDuration),
|
|
buyer,
|
|
c("token2", 50),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [reverse]: invalid lot size (larger than min increment)",
|
|
auctionArgs{Collateral, modName, c("token1", 60), c("token2", 50), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 50)}}, // put auction into reverse phase
|
|
bidArgs{buyer, c("token1", 58)}, // max lot at default 5% is 57
|
|
types.ErrLotTooLarge,
|
|
someTime.Add(types.DefaultReverseBidDuration),
|
|
buyer,
|
|
c("token2", 50),
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"collateral [reverse]: bidder replaces previous bid without funds",
|
|
auctionArgs{Collateral, modName, c("token1", 1000), c("token2", 1000), c("debt", 50), collateralAddrs, collateralWeights}, // lot, max bid
|
|
[]bidArgs{{buyer, c("token2", 1000)}},
|
|
bidArgs{buyer, c("token1", 100)}, // buyer has already bid all of their token2
|
|
nil,
|
|
someTime.Add(types.DefaultReverseBidDuration),
|
|
buyer,
|
|
c("token2", 1000),
|
|
true,
|
|
false,
|
|
},
|
|
}
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
// Setup test
|
|
tApp := app.NewTestApp()
|
|
|
|
// Set up module account
|
|
modName := "liquidator"
|
|
modBaseAcc := authtypes.NewBaseAccount(authtypes.NewModuleAddress(modName), nil, 0, 0)
|
|
modAcc := authtypes.NewModuleAccount(modBaseAcc, modName, []string{authtypes.Minter, authtypes.Burner}...)
|
|
|
|
// Set up normal accounts
|
|
addrs := []sdk.AccAddress{buyer, secondBuyer, collateralAddrs[0], collateralAddrs[1], collateralAddrs[2]}
|
|
|
|
// Initialize app
|
|
authGS := app.NewFundedGenStateWithSameCoinsWithModuleAccount(tApp.AppCodec(), initialBalance, addrs, modAcc)
|
|
params := types.NewParams(
|
|
types.DefaultMaxAuctionDuration,
|
|
types.DefaultForwardBidDuration,
|
|
types.DefaultReverseBidDuration,
|
|
types.DefaultIncrement,
|
|
types.DefaultIncrement,
|
|
types.DefaultIncrement,
|
|
)
|
|
|
|
auctionGs, err := types.NewGenesisState(types.DefaultNextAuctionID, params, []types.GenesisAuction{})
|
|
require.NoError(t, err)
|
|
|
|
moduleGs := tApp.AppCodec().MustMarshalJSON(auctionGs)
|
|
gs := app.GenesisState{types.ModuleName: moduleGs}
|
|
tApp.InitializeFromGenesisStates(authGS, gs)
|
|
|
|
ctx := tApp.NewContext(true, tmproto.Header{Height: 1, Time: someTime})
|
|
keeper := tApp.GetAuctionKeeper()
|
|
bank := tApp.GetBankKeeper()
|
|
|
|
err = tApp.FundModuleAccount(ctx, modName, cs(c("token1", 1000), c("token2", 1000), c("debt", 1000)))
|
|
require.NoError(t, err)
|
|
|
|
// Start Auction
|
|
var id uint64
|
|
switch tc.auctionArgs.auctionType {
|
|
case Surplus:
|
|
if tc.expectPanic {
|
|
require.Panics(t, func() {
|
|
id, err = keeper.StartSurplusAuction(ctx, tc.auctionArgs.seller, tc.auctionArgs.lot, tc.auctionArgs.bid.Denom)
|
|
})
|
|
} else {
|
|
id, err = keeper.StartSurplusAuction(ctx, tc.auctionArgs.seller, tc.auctionArgs.lot, tc.auctionArgs.bid.Denom)
|
|
}
|
|
case Debt:
|
|
id, err = keeper.StartDebtAuction(ctx, tc.auctionArgs.seller, tc.auctionArgs.bid, tc.auctionArgs.lot, tc.auctionArgs.debt)
|
|
case Collateral:
|
|
id, err = keeper.StartCollateralAuction(ctx, tc.auctionArgs.seller, tc.auctionArgs.lot, tc.auctionArgs.bid, tc.auctionArgs.addresses, tc.auctionArgs.weights, tc.auctionArgs.debt) // seller, lot, maxBid, otherPerson
|
|
default:
|
|
t.Fail()
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
|
|
// Place setup bids
|
|
for _, b := range tc.setupBids {
|
|
require.NoError(t, keeper.PlaceBid(ctx, id, b.bidder, b.amount))
|
|
}
|
|
|
|
// Close the auction early to test late bidding (if applicable)
|
|
if strings.Contains(tc.name, "closed") {
|
|
ctx = ctx.WithBlockTime(types.DistantFuture.Add(1))
|
|
}
|
|
|
|
// Store some state for use in checks
|
|
var oldBidder sdk.AccAddress
|
|
var oldBidderOldCoins sdk.Coins
|
|
|
|
oldAuction, found := keeper.GetAuction(ctx, id)
|
|
if found {
|
|
oldBidder = oldAuction.GetBidder()
|
|
}
|
|
|
|
if !oldBidder.Empty() {
|
|
oldBidderOldCoins = bank.GetAllBalances(ctx, oldBidder)
|
|
}
|
|
|
|
newBidderOldCoins := bank.GetAllBalances(ctx, tc.bidArgs.bidder)
|
|
|
|
// Place bid on auction
|
|
err = keeper.PlaceBid(ctx, id, tc.bidArgs.bidder, tc.bidArgs.amount)
|
|
|
|
// Check success/failure
|
|
if tc.expectPass {
|
|
require.NoError(t, err)
|
|
// Check auction was found
|
|
newAuction, found := keeper.GetAuction(ctx, id)
|
|
require.True(t, found)
|
|
// Check auction values
|
|
require.Equal(t, modName, newAuction.GetInitiator())
|
|
require.Equal(t, tc.expectedBidder, newAuction.GetBidder())
|
|
require.Equal(t, tc.expectedBid, newAuction.GetBid())
|
|
require.Equal(t, tc.expectedEndTime, newAuction.GetEndTime())
|
|
|
|
// Check coins have moved between bidder and previous bidder
|
|
bidAmt := tc.bidArgs.amount
|
|
switch tc.auctionArgs.auctionType {
|
|
case Debt:
|
|
bidAmt = oldAuction.GetBid()
|
|
case Collateral:
|
|
collatAuction, ok := oldAuction.(*types.CollateralAuction)
|
|
require.True(t, ok, tc.name)
|
|
if collatAuction.IsReversePhase() {
|
|
bidAmt = oldAuction.GetBid()
|
|
}
|
|
}
|
|
if oldBidder.Equals(tc.bidArgs.bidder) { // same bidder
|
|
require.Equal(t, newBidderOldCoins.Sub(bidAmt.Sub(oldAuction.GetBid())), bank.GetAllBalances(ctx, tc.bidArgs.bidder))
|
|
} else { // different bidder
|
|
require.Equal(t, newBidderOldCoins.Sub(bidAmt), bank.GetAllBalances(ctx, tc.bidArgs.bidder)) // wrapping in cs() to avoid comparing nil and empty coins
|
|
|
|
// handle checking debt coins for case debt auction has had no bids placed yet TODO make this less confusing
|
|
if oldBidder.Equals(authtypes.NewModuleAddress(oldAuction.GetInitiator())) {
|
|
require.Equal(t, oldBidderOldCoins.Add(oldAuction.GetBid()).Add(c("debt", oldAuction.GetBid().Amount.Int64())), bank.GetAllBalances(ctx, oldBidder))
|
|
} else if oldBidder.Empty() {
|
|
require.Equal(t, oldBidderOldCoins.Add(oldAuction.GetBid()).Add(c("debt", oldAuction.GetBid().Amount.Int64())), oldBidderOldCoins)
|
|
} else {
|
|
require.Equal(t, cs(oldBidderOldCoins.Add(oldAuction.GetBid())...), bank.GetAllBalances(ctx, oldBidder))
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// Check expected error code type
|
|
require.Error(t, err, "PlaceBid did not return an error")
|
|
require.ErrorIs(t, err, tc.expectedError)
|
|
|
|
// Check auction values
|
|
newAuction, found := keeper.GetAuction(ctx, id)
|
|
if found {
|
|
require.Equal(t, modName, newAuction.GetInitiator())
|
|
require.Equal(t, tc.expectedBidder, newAuction.GetBidder())
|
|
require.Equal(t, tc.expectedBid, newAuction.GetBid())
|
|
require.Equal(t, tc.expectedEndTime, newAuction.GetEndTime())
|
|
}
|
|
|
|
// Check coins have not moved
|
|
require.Equal(t, newBidderOldCoins, bank.GetAllBalances(ctx, tc.bidArgs.bidder))
|
|
if !oldBidder.Empty() {
|
|
require.Equal(t, oldBidderOldCoins, bank.GetAllBalances(ctx, oldBidder))
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|