mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-11-10 10:05:18 +00:00
464 lines
14 KiB
Go
464 lines
14 KiB
Go
package keeper_test
|
|
|
|
import (
|
|
"errors"
|
|
"math/rand"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/suite"
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/cosmos/cosmos-sdk/x/simulation"
|
|
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
|
tmtime "github.com/tendermint/tendermint/types/time"
|
|
|
|
"github.com/kava-labs/kava/app"
|
|
"github.com/kava-labs/kava/x/auction"
|
|
"github.com/kava-labs/kava/x/cdp/keeper"
|
|
"github.com/kava-labs/kava/x/cdp/types"
|
|
)
|
|
|
|
type SeizeTestSuite struct {
|
|
suite.Suite
|
|
|
|
keeper keeper.Keeper
|
|
addrs []sdk.AccAddress
|
|
app app.TestApp
|
|
cdps types.CDPs
|
|
ctx sdk.Context
|
|
liquidations liquidationTracker
|
|
}
|
|
|
|
type liquidationTracker struct {
|
|
xrp []uint64
|
|
btc []uint64
|
|
debt int64
|
|
}
|
|
|
|
func (suite *SeizeTestSuite) SetupTest() {
|
|
tApp := app.NewTestApp()
|
|
ctx := tApp.NewContext(true, abci.Header{Height: 1, Time: tmtime.Now()})
|
|
coins := []sdk.Coins{}
|
|
tracker := liquidationTracker{}
|
|
|
|
for j := 0; j < 100; j++ {
|
|
coins = append(coins, cs(c("btc", 100000000), c("xrp", 10000000000)))
|
|
}
|
|
_, addrs := app.GeneratePrivKeyAddressPairs(100)
|
|
|
|
authGS := app.NewAuthGenState(
|
|
addrs, coins)
|
|
tApp.InitializeFromGenesisStates(
|
|
authGS,
|
|
NewPricefeedGenStateMulti(),
|
|
NewCDPGenStateMulti(),
|
|
)
|
|
suite.ctx = ctx
|
|
suite.app = tApp
|
|
suite.keeper = tApp.GetCDPKeeper()
|
|
suite.cdps = types.CDPs{}
|
|
suite.addrs = addrs
|
|
suite.liquidations = tracker
|
|
}
|
|
|
|
func (suite *SeizeTestSuite) createCdps() {
|
|
tApp := app.NewTestApp()
|
|
ctx := tApp.NewContext(true, abci.Header{Height: 1, Time: tmtime.Now()})
|
|
cdps := make(types.CDPs, 100)
|
|
_, addrs := app.GeneratePrivKeyAddressPairs(100)
|
|
coins := []sdk.Coins{}
|
|
tracker := liquidationTracker{}
|
|
|
|
for j := 0; j < 100; j++ {
|
|
coins = append(coins, cs(c("btc", 100000000), c("xrp", 10000000000)))
|
|
}
|
|
|
|
authGS := app.NewAuthGenState(
|
|
addrs, coins)
|
|
tApp.InitializeFromGenesisStates(
|
|
authGS,
|
|
NewPricefeedGenStateMulti(),
|
|
NewCDPGenStateMulti(),
|
|
)
|
|
|
|
suite.ctx = ctx
|
|
suite.app = tApp
|
|
suite.keeper = tApp.GetCDPKeeper()
|
|
randSource := rand.New(rand.NewSource(int64(777)))
|
|
for j := 0; j < 100; j++ {
|
|
collateral := "xrp"
|
|
amount := 10000000000
|
|
debt := simulation.RandIntBetween(randSource, 750000000, 1249000000)
|
|
if j%2 == 0 {
|
|
collateral = "btc"
|
|
amount = 100000000
|
|
debt = simulation.RandIntBetween(randSource, 2700000000, 5332000000)
|
|
if debt >= 4000000000 {
|
|
tracker.btc = append(tracker.btc, uint64(j+1))
|
|
tracker.debt += int64(debt)
|
|
}
|
|
} else {
|
|
if debt >= 1000000000 {
|
|
tracker.xrp = append(tracker.xrp, uint64(j+1))
|
|
tracker.debt += int64(debt)
|
|
}
|
|
}
|
|
err := suite.keeper.AddCdp(suite.ctx, addrs[j], c(collateral, int64(amount)), c("usdx", int64(debt)), collateral+"-a")
|
|
suite.NoError(err)
|
|
c, f := suite.keeper.GetCDP(suite.ctx, collateral+"-a", uint64(j+1))
|
|
suite.True(f)
|
|
cdps[j] = c
|
|
}
|
|
|
|
suite.cdps = cdps
|
|
suite.addrs = addrs
|
|
suite.liquidations = tracker
|
|
}
|
|
|
|
func (suite *SeizeTestSuite) setPrice(price sdk.Dec, market string) {
|
|
pfKeeper := suite.app.GetPriceFeedKeeper()
|
|
|
|
pfKeeper.SetPrice(suite.ctx, sdk.AccAddress{}, market, price, suite.ctx.BlockTime().Add(time.Hour*3))
|
|
err := pfKeeper.SetCurrentPrices(suite.ctx, market)
|
|
suite.NoError(err)
|
|
pp, err := pfKeeper.GetCurrentPrice(suite.ctx, market)
|
|
suite.NoError(err)
|
|
suite.Equal(price, pp.Price)
|
|
}
|
|
|
|
func (suite *SeizeTestSuite) TestSeizeCollateral() {
|
|
suite.createCdps()
|
|
sk := suite.app.GetSupplyKeeper()
|
|
cdp, found := suite.keeper.GetCDP(suite.ctx, "xrp-a", uint64(2))
|
|
suite.True(found)
|
|
p := cdp.Principal.Amount
|
|
cl := cdp.Collateral.Amount
|
|
tpb := suite.keeper.GetTotalPrincipal(suite.ctx, "xrp-a", "usdx")
|
|
err := suite.keeper.SeizeCollateral(suite.ctx, cdp)
|
|
suite.NoError(err)
|
|
tpa := suite.keeper.GetTotalPrincipal(suite.ctx, "xrp-a", "usdx")
|
|
suite.Equal(tpb.Sub(tpa), p)
|
|
auctionKeeper := suite.app.GetAuctionKeeper()
|
|
_, found = auctionKeeper.GetAuction(suite.ctx, auction.DefaultNextAuctionID)
|
|
suite.True(found)
|
|
auctionMacc := sk.GetModuleAccount(suite.ctx, auction.ModuleName)
|
|
suite.Equal(cs(c("debt", p.Int64()), c("xrp", cl.Int64())), auctionMacc.GetCoins())
|
|
ak := suite.app.GetAccountKeeper()
|
|
acc := ak.GetAccount(suite.ctx, suite.addrs[1])
|
|
suite.Equal(p.Int64(), acc.GetCoins().AmountOf("usdx").Int64())
|
|
err = suite.keeper.WithdrawCollateral(suite.ctx, suite.addrs[1], suite.addrs[1], c("xrp", 10), "xrp-a")
|
|
suite.Require().True(errors.Is(err, types.ErrCdpNotFound))
|
|
}
|
|
|
|
func (suite *SeizeTestSuite) TestSeizeCollateralMultiDeposit() {
|
|
suite.createCdps()
|
|
sk := suite.app.GetSupplyKeeper()
|
|
cdp, found := suite.keeper.GetCDP(suite.ctx, "xrp-a", uint64(2))
|
|
suite.True(found)
|
|
err := suite.keeper.DepositCollateral(suite.ctx, suite.addrs[1], suite.addrs[0], c("xrp", 6999000000), "xrp-a")
|
|
suite.NoError(err)
|
|
cdp, found = suite.keeper.GetCDP(suite.ctx, "xrp-a", uint64(2))
|
|
suite.True(found)
|
|
deposits := suite.keeper.GetDeposits(suite.ctx, cdp.ID)
|
|
suite.Equal(2, len(deposits))
|
|
p := cdp.Principal.Amount
|
|
cl := cdp.Collateral.Amount
|
|
tpb := suite.keeper.GetTotalPrincipal(suite.ctx, "xrp-a", "usdx")
|
|
err = suite.keeper.SeizeCollateral(suite.ctx, cdp)
|
|
suite.NoError(err)
|
|
tpa := suite.keeper.GetTotalPrincipal(suite.ctx, "xrp-a", "usdx")
|
|
suite.Equal(tpb.Sub(tpa), p)
|
|
auctionMacc := sk.GetModuleAccount(suite.ctx, auction.ModuleName)
|
|
suite.Equal(cs(c("debt", p.Int64()), c("xrp", cl.Int64())), auctionMacc.GetCoins())
|
|
ak := suite.app.GetAccountKeeper()
|
|
acc := ak.GetAccount(suite.ctx, suite.addrs[1])
|
|
suite.Equal(p.Int64(), acc.GetCoins().AmountOf("usdx").Int64())
|
|
err = suite.keeper.WithdrawCollateral(suite.ctx, suite.addrs[1], suite.addrs[1], c("xrp", 10), "xrp-a")
|
|
suite.Require().True(errors.Is(err, types.ErrCdpNotFound))
|
|
}
|
|
|
|
func (suite *SeizeTestSuite) TestLiquidateCdps() {
|
|
suite.createCdps()
|
|
sk := suite.app.GetSupplyKeeper()
|
|
acc := sk.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
originalXrpCollateral := acc.GetCoins().AmountOf("xrp")
|
|
suite.setPrice(d("0.2"), "xrp:usd")
|
|
p, found := suite.keeper.GetCollateral(suite.ctx, "xrp-a")
|
|
suite.True(found)
|
|
suite.keeper.LiquidateCdps(suite.ctx, "xrp:usd", "xrp-a", p.LiquidationRatio, p.CheckCollateralizationIndexCount)
|
|
acc = sk.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
finalXrpCollateral := acc.GetCoins().AmountOf("xrp")
|
|
seizedXrpCollateral := originalXrpCollateral.Sub(finalXrpCollateral)
|
|
xrpLiquidations := int(seizedXrpCollateral.Quo(i(10000000000)).Int64())
|
|
suite.Equal(10, xrpLiquidations)
|
|
}
|
|
|
|
func (suite *SeizeTestSuite) TestApplyLiquidationPenalty() {
|
|
penalty := suite.keeper.ApplyLiquidationPenalty(suite.ctx, "xrp-a", i(1000))
|
|
suite.Equal(i(50), penalty)
|
|
penalty = suite.keeper.ApplyLiquidationPenalty(suite.ctx, "btc-a", i(1000))
|
|
suite.Equal(i(25), penalty)
|
|
penalty = suite.keeper.ApplyLiquidationPenalty(suite.ctx, "xrp-a", i(675760172))
|
|
suite.Equal(i(33788009), penalty)
|
|
suite.Panics(func() { suite.keeper.ApplyLiquidationPenalty(suite.ctx, "lol-a", i(1000)) })
|
|
}
|
|
|
|
func (suite *SeizeTestSuite) TestKeeperLiquidation() {
|
|
type args struct {
|
|
ctype string
|
|
blockTime time.Time
|
|
initialPrice sdk.Dec
|
|
finalPrice sdk.Dec
|
|
collateral sdk.Coin
|
|
principal sdk.Coin
|
|
expectedKeeperCoins sdk.Coins // additional coins (if any) the borrower address should have after successfully liquidating position
|
|
expectedAuctions auction.Auctions // the auctions we should expect to find have been started
|
|
}
|
|
|
|
type errArgs struct {
|
|
expectLiquidate bool
|
|
contains string
|
|
}
|
|
|
|
type test struct {
|
|
name string
|
|
args args
|
|
errArgs errArgs
|
|
}
|
|
|
|
// Set up auction constants
|
|
layout := "2006-01-02T15:04:05.000Z"
|
|
endTimeStr := "9000-01-01T00:00:00.000Z"
|
|
endTime, _ := time.Parse(layout, endTimeStr)
|
|
addr, _ := sdk.AccAddressFromBech32("kava1ze7y9qwdddejmy7jlw4cymqqlt2wh05yhwmrv2")
|
|
|
|
testCases := []test{
|
|
{
|
|
"valid liquidation",
|
|
args{
|
|
"btc-a",
|
|
time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
d("20000.00"),
|
|
d("19000.0"),
|
|
c("btc", 10000000),
|
|
c("usdx", 1333330000),
|
|
cs(c("btc", 100100000), c("xrp", 10000000000)),
|
|
auction.Auctions{
|
|
auction.CollateralAuction{
|
|
BaseAuction: auction.BaseAuction{
|
|
ID: 1,
|
|
Initiator: "liquidator",
|
|
Lot: c("btc", 9900000),
|
|
Bidder: nil,
|
|
Bid: c("usdx", 0),
|
|
HasReceivedBids: false,
|
|
EndTime: endTime,
|
|
MaxEndTime: endTime,
|
|
},
|
|
CorrespondingDebt: c("debt", 1333330000),
|
|
MaxBid: c("usdx", 1366663250),
|
|
LotReturns: auction.WeightedAddresses{[]sdk.AccAddress{addr}, []sdk.Int{sdk.NewInt(9900000)}},
|
|
},
|
|
},
|
|
},
|
|
errArgs{
|
|
true,
|
|
"",
|
|
},
|
|
},
|
|
{
|
|
"invalid - not below collateralization ratio",
|
|
args{
|
|
"btc-a",
|
|
time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
d("20000.00"),
|
|
d("21000.0"),
|
|
c("btc", 10000000),
|
|
c("usdx", 1333330000),
|
|
cs(),
|
|
auction.Auctions{},
|
|
},
|
|
errArgs{
|
|
false,
|
|
"collateral ratio not below liquidation ratio",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(tc.name, func() {
|
|
suite.SetupTest()
|
|
// setup pricefeed
|
|
pk := suite.app.GetPriceFeedKeeper()
|
|
_, err := pk.SetPrice(suite.ctx, sdk.AccAddress{}, "btc:usd", tc.args.initialPrice, suite.ctx.BlockTime().Add(time.Hour*24))
|
|
suite.Require().NoError(err)
|
|
err = pk.SetCurrentPrices(suite.ctx, "btc:usd")
|
|
suite.Require().NoError(err)
|
|
|
|
// setup cdp state
|
|
suite.keeper.SetPreviousAccrualTime(suite.ctx, tc.args.ctype, suite.ctx.BlockTime())
|
|
suite.keeper.SetInterestFactor(suite.ctx, tc.args.ctype, sdk.OneDec())
|
|
err = suite.keeper.AddCdp(suite.ctx, suite.addrs[0], tc.args.collateral, tc.args.principal, tc.args.ctype)
|
|
suite.Require().NoError(err)
|
|
|
|
// update pricefeed
|
|
_, err = pk.SetPrice(suite.ctx, sdk.AccAddress{}, "btc:usd", tc.args.finalPrice, suite.ctx.BlockTime().Add(time.Hour*24))
|
|
suite.Require().NoError(err)
|
|
err = pk.SetCurrentPrices(suite.ctx, "btc:usd")
|
|
suite.Require().NoError(err)
|
|
|
|
_, found := suite.keeper.GetCdpByOwnerAndCollateralType(suite.ctx, suite.addrs[0], tc.args.ctype)
|
|
suite.Require().True(found)
|
|
|
|
err = suite.keeper.AttemptKeeperLiquidation(suite.ctx, suite.addrs[1], suite.addrs[0], tc.args.ctype)
|
|
|
|
if tc.errArgs.expectLiquidate {
|
|
suite.Require().NoError(err)
|
|
|
|
_, found = suite.keeper.GetCdpByOwnerAndCollateralType(suite.ctx, suite.addrs[0], tc.args.ctype)
|
|
suite.Require().False(found)
|
|
|
|
ak := suite.app.GetAuctionKeeper()
|
|
auctions := ak.GetAllAuctions(suite.ctx)
|
|
suite.Require().Equal(tc.args.expectedAuctions, auctions)
|
|
|
|
ack := suite.app.GetAccountKeeper()
|
|
keeper := ack.GetAccount(suite.ctx, suite.addrs[1])
|
|
suite.Require().Equal(tc.args.expectedKeeperCoins, keeper.GetCoins())
|
|
} else {
|
|
suite.Require().Error(err)
|
|
suite.Require().True(strings.Contains(err.Error(), tc.errArgs.contains))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *SeizeTestSuite) TestBeginBlockerLiquidation() {
|
|
type args struct {
|
|
ctype string
|
|
blockTime time.Time
|
|
initialPrice sdk.Dec
|
|
finalPrice sdk.Dec
|
|
collaterals sdk.Coins
|
|
principals sdk.Coins
|
|
expectedAuctions auction.Auctions // the auctions we should expect to find have been started
|
|
}
|
|
type errArgs struct {
|
|
expectLiquidate bool
|
|
contains string
|
|
}
|
|
type test struct {
|
|
name string
|
|
args args
|
|
errArgs errArgs
|
|
}
|
|
// Set up auction constants
|
|
layout := "2006-01-02T15:04:05.000Z"
|
|
endTimeStr := "9000-01-01T00:00:00.000Z"
|
|
endTime, _ := time.Parse(layout, endTimeStr)
|
|
addr, _ := sdk.AccAddressFromBech32("kava1ze7y9qwdddejmy7jlw4cymqqlt2wh05yhwmrv2")
|
|
|
|
testCases := []test{
|
|
{
|
|
"1 liquidation",
|
|
args{
|
|
"btc-a",
|
|
time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
d("20000.00"),
|
|
d("10000.00"),
|
|
sdk.Coins{c("btc", 10000000), c("btc", 10000000)},
|
|
sdk.Coins{c("usdx", 1000000000), c("usdx", 500000000)},
|
|
auction.Auctions{
|
|
auction.CollateralAuction{
|
|
BaseAuction: auction.BaseAuction{
|
|
ID: 1,
|
|
Initiator: "liquidator",
|
|
Lot: c("btc", 10000000),
|
|
Bidder: nil,
|
|
Bid: c("usdx", 0),
|
|
HasReceivedBids: false,
|
|
EndTime: endTime,
|
|
MaxEndTime: endTime,
|
|
},
|
|
CorrespondingDebt: c("debt", 1000000000),
|
|
MaxBid: c("usdx", 1025000000),
|
|
LotReturns: auction.WeightedAddresses{[]sdk.AccAddress{addr}, []sdk.Int{sdk.NewInt(10000000)}},
|
|
},
|
|
},
|
|
},
|
|
errArgs{
|
|
true,
|
|
"",
|
|
},
|
|
},
|
|
{
|
|
"no liquidation",
|
|
args{
|
|
"btc-a",
|
|
time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC),
|
|
d("20000.00"),
|
|
d("10000.00"),
|
|
sdk.Coins{c("btc", 10000000), c("btc", 10000000)},
|
|
sdk.Coins{c("usdx", 500000000), c("usdx", 500000000)},
|
|
auction.Auctions{},
|
|
},
|
|
errArgs{
|
|
false,
|
|
"collateral ratio not below liquidation ratio",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(tc.name, func() {
|
|
suite.SetupTest()
|
|
// setup pricefeed
|
|
pk := suite.app.GetPriceFeedKeeper()
|
|
_, err := pk.SetPrice(suite.ctx, sdk.AccAddress{}, "btc:usd", tc.args.initialPrice, suite.ctx.BlockTime().Add(time.Hour*24))
|
|
suite.Require().NoError(err)
|
|
err = pk.SetCurrentPrices(suite.ctx, "btc:usd")
|
|
suite.Require().NoError(err)
|
|
|
|
// setup cdp state
|
|
suite.keeper.SetPreviousAccrualTime(suite.ctx, tc.args.ctype, suite.ctx.BlockTime())
|
|
suite.keeper.SetInterestFactor(suite.ctx, tc.args.ctype, sdk.OneDec())
|
|
|
|
for idx, col := range tc.args.collaterals {
|
|
err := suite.keeper.AddCdp(suite.ctx, suite.addrs[idx], col, tc.args.principals[idx], tc.args.ctype)
|
|
suite.Require().NoError(err)
|
|
}
|
|
|
|
// update pricefeed
|
|
_, err = pk.SetPrice(suite.ctx, sdk.AccAddress{}, "btc:usd", tc.args.finalPrice, suite.ctx.BlockTime().Add(time.Hour*24))
|
|
suite.Require().NoError(err)
|
|
err = pk.SetCurrentPrices(suite.ctx, "btc:usd")
|
|
suite.Require().NoError(err)
|
|
|
|
_ = suite.app.BeginBlocker(suite.ctx, abci.RequestBeginBlock{Header: suite.ctx.BlockHeader()})
|
|
ak := suite.app.GetAuctionKeeper()
|
|
auctions := ak.GetAllAuctions(suite.ctx)
|
|
if tc.errArgs.expectLiquidate {
|
|
suite.Require().Equal(tc.args.expectedAuctions, auctions)
|
|
for _, a := range auctions {
|
|
ca := a.(auction.CollateralAuction)
|
|
_, found := suite.keeper.GetCdpByOwnerAndCollateralType(suite.ctx, ca.LotReturns.Addresses[0], tc.args.ctype)
|
|
suite.Require().False(found)
|
|
}
|
|
} else {
|
|
suite.Require().Equal(0, len(auctions))
|
|
for idx, _ := range tc.args.collaterals {
|
|
_, found := suite.keeper.GetCdpByOwnerAndCollateralType(suite.ctx, suite.addrs[idx], tc.args.ctype)
|
|
suite.Require().True(found)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSeizeTestSuite(t *testing.T) {
|
|
suite.Run(t, new(SeizeTestSuite))
|
|
}
|