mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-12-27 00:35:18 +00:00
6ea518960a
* optimize cdp begin blocker by removing unnecessary checks, reusing data and prefix stores in loops, and reducing number of repeated calculations * fix panic for new cdp types if both previous accural time and global interest factor are not set * do not touch global interest factor if no CDP's exist; revert to panic if global interest factor is not found since this is an unreachable state by normal keeper operation -- it can only be reached if store is modified outside of public interface and normal operation
376 lines
15 KiB
Go
376 lines
15 KiB
Go
package cdp_test
|
|
|
|
import (
|
|
"math/rand"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/suite"
|
|
|
|
sdkmath "cosmossdk.io/math"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/cosmos/cosmos-sdk/types/simulation"
|
|
|
|
abci "github.com/cometbft/cometbft/abci/types"
|
|
tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
|
|
tmtime "github.com/cometbft/cometbft/types/time"
|
|
|
|
"github.com/kava-labs/kava/app"
|
|
auctiontypes "github.com/kava-labs/kava/x/auction/types"
|
|
"github.com/kava-labs/kava/x/cdp"
|
|
"github.com/kava-labs/kava/x/cdp/keeper"
|
|
"github.com/kava-labs/kava/x/cdp/types"
|
|
pricefeedtypes "github.com/kava-labs/kava/x/pricefeed/types"
|
|
)
|
|
|
|
type ModuleTestSuite 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 *ModuleTestSuite) SetupTest() {
|
|
tApp := app.NewTestApp()
|
|
ctx := tApp.NewContext(true, tmproto.Header{Height: 1, Time: tmtime.Now()})
|
|
tracker := liquidationTracker{}
|
|
|
|
coins := cs(c("btc", 100000000), c("xrp", 10000000000), c("erc20/usdc", 10000000000))
|
|
_, addrs := app.GeneratePrivKeyAddressPairs(100)
|
|
authGS := app.NewFundedGenStateWithSameCoins(tApp.AppCodec(), coins, addrs)
|
|
tApp.InitializeFromGenesisStates(
|
|
authGS,
|
|
NewPricefeedGenStateMulti(tApp.AppCodec()),
|
|
NewCDPGenStateMulti(tApp.AppCodec()),
|
|
)
|
|
suite.ctx = ctx
|
|
suite.app = tApp
|
|
suite.keeper = tApp.GetCDPKeeper()
|
|
suite.cdps = types.CDPs{}
|
|
suite.addrs = addrs
|
|
suite.liquidations = tracker
|
|
}
|
|
|
|
func (suite *ModuleTestSuite) createCdps() {
|
|
tApp := app.NewTestApp()
|
|
ctx := tApp.NewContext(true, tmproto.Header{Height: 1, Time: tmtime.Now()})
|
|
cdps := make(types.CDPs, 100)
|
|
tracker := liquidationTracker{}
|
|
|
|
coins := cs(c("btc", 100000000), c("xrp", 10000000000), c("erc20/usdc", 10000000000))
|
|
_, addrs := app.GeneratePrivKeyAddressPairs(100)
|
|
|
|
authGS := app.NewFundedGenStateWithSameCoins(tApp.AppCodec(), coins, addrs)
|
|
tApp.InitializeFromGenesisStates(
|
|
authGS,
|
|
NewPricefeedGenStateMulti(tApp.AppCodec()),
|
|
NewCDPGenStateMulti(tApp.AppCodec()),
|
|
)
|
|
|
|
suite.ctx = ctx
|
|
suite.app = tApp
|
|
suite.keeper = tApp.GetCDPKeeper()
|
|
|
|
// create 100 cdps
|
|
for j := 0; j < 100; j++ {
|
|
// 50 of the cdps will be collateralized with xrp
|
|
collateral := "xrp"
|
|
amount := 10000000000
|
|
debt := simulation.RandIntBetween(rand.New(rand.NewSource(int64(j))), 750000000, 1249000000)
|
|
// the other half (50) will be collateralized with btc
|
|
if j%2 == 0 {
|
|
collateral = "btc"
|
|
amount = 100000000
|
|
debt = simulation.RandIntBetween(rand.New(rand.NewSource(int64(j))), 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)
|
|
}
|
|
}
|
|
suite.Nil(suite.keeper.AddCdp(suite.ctx, addrs[j], c(collateral, int64(amount)), c("usdx", int64(debt)), collateral+"-a"))
|
|
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 *ModuleTestSuite) setPrice(price sdk.Dec, market string) {
|
|
pfKeeper := suite.app.GetPriceFeedKeeper()
|
|
|
|
_, err := pfKeeper.SetPrice(suite.ctx, sdk.AccAddress{}, market, price, suite.ctx.BlockTime().Add(time.Hour*3))
|
|
suite.NoError(err)
|
|
|
|
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 *ModuleTestSuite) TestBeginBlockNewCdpTypeSetsGlobalInterest() {
|
|
suite.createCdps()
|
|
|
|
// add a new collateral that does not have previous accumulation time or global interest factor set
|
|
params := suite.keeper.GetParams(suite.ctx)
|
|
usdcCollateral := types.CollateralParam{
|
|
Denom: "erc20/usdc",
|
|
Type: "erc20-usdc",
|
|
LiquidationRatio: sdk.MustNewDecFromStr("1.01"),
|
|
DebtLimit: sdk.NewInt64Coin("usdx", 500000000000),
|
|
StabilityFee: sdk.OneDec(),
|
|
AuctionSize: sdkmath.NewIntFromUint64(10000000000),
|
|
LiquidationPenalty: sdk.MustNewDecFromStr("0.05"),
|
|
CheckCollateralizationIndexCount: sdkmath.NewInt(10),
|
|
KeeperRewardPercentage: sdk.MustNewDecFromStr("0.01"),
|
|
SpotMarketID: "usdc:usd",
|
|
LiquidationMarketID: "usdc:usd",
|
|
ConversionFactor: sdkmath.NewInt(6),
|
|
}
|
|
usdtCollateral := types.CollateralParam{
|
|
Denom: "erc20/usdt",
|
|
Type: "erc20-usdt",
|
|
LiquidationRatio: sdk.MustNewDecFromStr("1.01"),
|
|
DebtLimit: sdk.NewInt64Coin("usdx", 500000000000),
|
|
StabilityFee: sdk.OneDec(),
|
|
AuctionSize: sdkmath.NewIntFromUint64(10000000000),
|
|
LiquidationPenalty: sdk.MustNewDecFromStr("0.05"),
|
|
CheckCollateralizationIndexCount: sdkmath.NewInt(10),
|
|
KeeperRewardPercentage: sdk.MustNewDecFromStr("0.01"),
|
|
SpotMarketID: "usdt:usd",
|
|
LiquidationMarketID: "usdt:usd",
|
|
ConversionFactor: sdkmath.NewInt(18),
|
|
}
|
|
newCollaterals := []types.CollateralParam{usdcCollateral, usdtCollateral}
|
|
params.CollateralParams = append(params.CollateralParams, newCollaterals...)
|
|
suite.keeper.SetParams(suite.ctx, params)
|
|
|
|
// setup market for cdp collateral
|
|
priceFeedKeeper := suite.app.GetPriceFeedKeeper()
|
|
priceParams := priceFeedKeeper.GetParams(suite.ctx)
|
|
newMarkets := []pricefeedtypes.Market{
|
|
{MarketID: "usdc:usd", BaseAsset: "usdc", QuoteAsset: "usd", Oracles: []sdk.AccAddress{}, Active: true},
|
|
{MarketID: "usdt:usd", BaseAsset: "usdt", QuoteAsset: "usd", Oracles: []sdk.AccAddress{}, Active: true},
|
|
}
|
|
priceParams.Markets = append(priceParams.Markets, newMarkets...)
|
|
priceFeedKeeper.SetParams(suite.ctx, priceParams)
|
|
suite.setPrice(d("1"), "usdc:usd")
|
|
suite.keeper.UpdatePricefeedStatus(suite.ctx, usdcCollateral.SpotMarketID)
|
|
suite.setPrice(d("1"), "usdt:usd")
|
|
suite.keeper.UpdatePricefeedStatus(suite.ctx, usdtCollateral.SpotMarketID)
|
|
|
|
// create a CDP for USDC, no CDPS for USDT
|
|
err := suite.keeper.AddCdp(suite.ctx, suite.addrs[0], c(usdcCollateral.Denom, 100000000), c("usdx", 10000000), usdcCollateral.Type)
|
|
suite.Require().NoError(err)
|
|
|
|
// ensure begin block does not panic due to no accumulation time or no global interest factor
|
|
suite.Require().NotPanics(func() {
|
|
cdp.BeginBlocker(suite.ctx, abci.RequestBeginBlock{Header: suite.ctx.BlockHeader()}, suite.keeper)
|
|
}, "expected begin blocker not to panic")
|
|
|
|
// set by accumulate interest (or add cdp above)
|
|
// usdc has accural time set
|
|
previousAccrualTime, found := suite.keeper.GetPreviousAccrualTime(suite.ctx, usdcCollateral.Type)
|
|
suite.Require().True(found, "expected previous accrual time for new market to be set")
|
|
suite.Equal(suite.ctx.BlockTime(), previousAccrualTime, "expected previous accrual time to equal block time")
|
|
// usdt has accural time set
|
|
previousAccrualTime, found = suite.keeper.GetPreviousAccrualTime(suite.ctx, usdtCollateral.Type)
|
|
suite.Require().True(found, "expected previous accrual time for new market to be set")
|
|
suite.Equal(suite.ctx.BlockTime(), previousAccrualTime, "expected previous accrual time to equal block time")
|
|
|
|
// set for USDC by AddCdp
|
|
globalInterestFactor, found := suite.keeper.GetInterestFactor(suite.ctx, usdcCollateral.Type)
|
|
suite.Require().True(found, "expected global interest factor for new collateral to be set")
|
|
suite.Equal(sdk.OneDec(), globalInterestFactor, "expected global interest factor to equal 1")
|
|
// not set for USDT since it has no cdps
|
|
globalInterestFactor, found = suite.keeper.GetInterestFactor(suite.ctx, usdtCollateral.Type)
|
|
suite.Require().False(found, "expected global interest factor for new collateral to not be set")
|
|
suite.Equal(sdk.ZeroDec(), globalInterestFactor, "expected global interest factor to equal 0")
|
|
}
|
|
|
|
func (suite *ModuleTestSuite) TestBeginBlock() {
|
|
// test setup, creating
|
|
// 50 xrp cdps each with
|
|
// collateral: 10000000000
|
|
// debt: between 750000000 - 1249000000
|
|
// if debt above 10000000000,
|
|
// cdp added to tracker / liquidation list
|
|
// debt total added to trackers debt total
|
|
// 50 btc cdps each with
|
|
// collateral: 10000000000
|
|
// debt: between 2700000000 - 5332000000
|
|
// if debt above 4000000000,
|
|
// cdp added to tracker / liquidation list
|
|
// debt total added to trackers debt total
|
|
|
|
// naively we expect roughly half of the cdps to be above the debt tracking floor, roughly 25 of them collaterallized with xrp, the other 25 with btcb
|
|
|
|
// usdx is the principal for all cdps
|
|
suite.createCdps()
|
|
ak := suite.app.GetAccountKeeper()
|
|
bk := suite.app.GetBankKeeper()
|
|
|
|
// test case 1 setup
|
|
acc := ak.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
// track how much xrp collateral exists in the cdp module
|
|
originalXrpCollateral := bk.GetBalance(suite.ctx, acc.GetAddress(), "xrp").Amount
|
|
// set the trading price for xrp:usd pools
|
|
suite.setPrice(d("0.2"), "xrp:usd")
|
|
|
|
// test case 1 execution
|
|
cdp.BeginBlocker(suite.ctx, abci.RequestBeginBlock{Header: suite.ctx.BlockHeader()}, suite.keeper)
|
|
|
|
// test case 1 assert
|
|
acc = ak.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
// get the current amount of xrp held by the cdp module
|
|
finalXrpCollateral := bk.GetBalance(suite.ctx, acc.GetAddress(), "xrp").Amount
|
|
seizedXrpCollateral := originalXrpCollateral.Sub(finalXrpCollateral)
|
|
// calculate the number of cdps that were liquidated based on the total
|
|
// seized collateral divided by the size of each cdp when it was created
|
|
xrpLiquidations := int(seizedXrpCollateral.Quo(i(10000000000)).Int64())
|
|
// should be 10 because...?
|
|
suite.Equal(10, xrpLiquidations)
|
|
|
|
// btc collateral test case setup
|
|
acc = ak.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
originalBtcCollateral := bk.GetBalance(suite.ctx, acc.GetAddress(), "btc").Amount
|
|
// set the trading price for btc:usd pools
|
|
suite.setPrice(d("6000"), "btc:usd")
|
|
|
|
// btc collateral test case execution
|
|
cdp.BeginBlocker(suite.ctx, abci.RequestBeginBlock{Header: suite.ctx.BlockHeader()}, suite.keeper)
|
|
|
|
// btc collateral test case assertion 1
|
|
acc = ak.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
finalBtcCollateral := bk.GetBalance(suite.ctx, acc.GetAddress(), "btc").Amount
|
|
seizedBtcCollateral := originalBtcCollateral.Sub(finalBtcCollateral)
|
|
// calculate the number of btc cdps that were liquidated based on the
|
|
// total seized collateral divided by the fixed size of each cdp
|
|
// when it was created during test setup
|
|
btcLiquidations := int(seizedBtcCollateral.Quo(i(100000000)).Int64())
|
|
suite.Equal(10, btcLiquidations)
|
|
|
|
// btc collateral test case assertion 2
|
|
// test that the auction module has a balance equal to the amount of collateral seized
|
|
acc = ak.GetModuleAccount(suite.ctx, auctiontypes.ModuleName)
|
|
// should be this exact value because...?
|
|
suite.Equal(int64(71955653865), bk.GetBalance(suite.ctx, acc.GetAddress(), "debt").Amount.Int64())
|
|
}
|
|
|
|
func (suite *ModuleTestSuite) TestSeizeSingleCdpWithFees() {
|
|
// test setup
|
|
// starting with zero cdps, add a single cdp of
|
|
// xrp backed 1:1 with usdx
|
|
err := suite.keeper.AddCdp(suite.ctx, suite.addrs[0], c("xrp", 10000000000), c("usdx", 1000000000), "xrp-a")
|
|
suite.NoError(err)
|
|
// verify the total value of all assets in cdps composed of xrp-a/usdx pair equals the amount of the single cdp we just added above
|
|
suite.Equal(i(1000000000), suite.keeper.GetTotalPrincipal(suite.ctx, "xrp-a", "usdx"))
|
|
ak := suite.app.GetAccountKeeper()
|
|
bk := suite.app.GetBankKeeper()
|
|
|
|
cdpMacc := ak.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
suite.Equal(i(1000000000), bk.GetBalance(suite.ctx, cdpMacc.GetAddress(), "debt").Amount)
|
|
for i := 0; i < 100; i++ {
|
|
suite.ctx = suite.ctx.WithBlockTime(suite.ctx.BlockTime().Add(time.Second * 6))
|
|
cdp.BeginBlocker(suite.ctx, abci.RequestBeginBlock{Header: suite.ctx.BlockHeader()}, suite.keeper)
|
|
}
|
|
|
|
cdpMacc = ak.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
suite.Equal(i(1000000891), (bk.GetBalance(suite.ctx, cdpMacc.GetAddress(), "debt").Amount))
|
|
cdp, _ := suite.keeper.GetCDP(suite.ctx, "xrp-a", 1)
|
|
|
|
err = suite.keeper.SeizeCollateral(suite.ctx, cdp)
|
|
suite.NoError(err)
|
|
_, found := suite.keeper.GetCDP(suite.ctx, "xrp-a", 1)
|
|
suite.False(found)
|
|
}
|
|
|
|
func (suite *ModuleTestSuite) TestCDPBeginBlockerRunsOnlyOnConfiguredInterval() {
|
|
// test setup, creating
|
|
// 50 xrp cdps each with
|
|
// collateral: 10000000000
|
|
// debt: between 750000000 - 1249000000
|
|
// if debt above 10000000000,
|
|
// cdp added to tracker / liquidation list
|
|
// debt total added to trackers debt total
|
|
// 50 btc cdps each with
|
|
// collateral: 10000000000
|
|
// debt: between 2700000000 - 5332000000
|
|
// if debt above 4000000000,
|
|
// cdp added to tracker / liquidation list
|
|
// debt total added to trackers debt total
|
|
|
|
// naively we expect roughly half of the cdps to be above the debt tracking floor, roughly 25 of them collaterallized with xrp, the other 25 with btcb
|
|
|
|
// usdx is the principal for all cdps
|
|
suite.createCdps()
|
|
ak := suite.app.GetAccountKeeper()
|
|
bk := suite.app.GetBankKeeper()
|
|
|
|
// set the cdp begin blocker to run every other block
|
|
params := suite.keeper.GetParams(suite.ctx)
|
|
params.LiquidationBlockInterval = 2
|
|
suite.keeper.SetParams(suite.ctx, params)
|
|
|
|
// test case 1 setup
|
|
acc := ak.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
// track how much xrp collateral exists in the cdp module
|
|
originalXrpCollateral := bk.GetBalance(suite.ctx, acc.GetAddress(), "xrp").Amount
|
|
// set the trading price for xrp:usd pools
|
|
suite.setPrice(d("0.2"), "xrp:usd")
|
|
|
|
// test case 1 execution
|
|
cdp.BeginBlocker(suite.ctx, abci.RequestBeginBlock{Header: suite.ctx.BlockHeader()}, suite.keeper)
|
|
|
|
// test case 1 assert
|
|
acc = ak.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
// get the current amount of xrp held by the cdp module
|
|
finalXrpCollateral := bk.GetBalance(suite.ctx, acc.GetAddress(), "xrp").Amount
|
|
seizedXrpCollateral := originalXrpCollateral.Sub(finalXrpCollateral)
|
|
// calculate the number of cdps that were liquidated based on the total
|
|
// seized collateral divided by the size of each cdp when it was created
|
|
xrpLiquidations := int(seizedXrpCollateral.Quo(i(10000000000)).Int64())
|
|
// should be 0 because the cdp begin blocker is configured to
|
|
// skip execution every odd numbered block
|
|
suite.Equal(0, xrpLiquidations, "expected cdp begin blocker not to run liqudations")
|
|
|
|
// test case 2 setup
|
|
// simulate running the second block of the chain
|
|
suite.ctx = suite.ctx.WithBlockHeight(2)
|
|
|
|
// test case 2 execution
|
|
cdp.BeginBlocker(suite.ctx, abci.RequestBeginBlock{Header: suite.ctx.BlockHeader()}, suite.keeper)
|
|
|
|
// test case 2 assert
|
|
acc = ak.GetModuleAccount(suite.ctx, types.ModuleName)
|
|
// get the current amount of xrp held by the cdp module
|
|
finalXrpCollateral = bk.GetBalance(suite.ctx, acc.GetAddress(), "xrp").Amount
|
|
seizedXrpCollateral = originalXrpCollateral.Sub(finalXrpCollateral)
|
|
// calculate the number of cdps that were liquidated based on the total
|
|
// seized collateral divided by the size of each cdp when it was created
|
|
xrpLiquidations = int(seizedXrpCollateral.Quo(i(10000000000)).Int64())
|
|
suite.Greater(xrpLiquidations, 0, "expected cdp begin blocker to run liquidations")
|
|
}
|
|
|
|
func TestModuleTestSuite(t *testing.T) {
|
|
suite.Run(t, new(ModuleTestSuite))
|
|
}
|