mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-11-10 18:15:19 +00:00
332 lines
11 KiB
Go
332 lines
11 KiB
Go
package cdp_test
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
abci "github.com/cometbft/cometbft/abci/types"
|
|
tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
|
|
tmtime "github.com/cometbft/cometbft/types/time"
|
|
"github.com/stretchr/testify/suite"
|
|
|
|
sdkmath "cosmossdk.io/math"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
|
|
"github.com/0glabs/0g-chain/app"
|
|
"github.com/0glabs/0g-chain/x/cdp"
|
|
"github.com/0glabs/0g-chain/x/cdp/keeper"
|
|
"github.com/0glabs/0g-chain/x/cdp/types"
|
|
)
|
|
|
|
type GenesisTestSuite struct {
|
|
suite.Suite
|
|
|
|
app app.TestApp
|
|
ctx sdk.Context
|
|
genTime time.Time
|
|
keeper keeper.Keeper
|
|
addrs []sdk.AccAddress
|
|
}
|
|
|
|
func (suite *GenesisTestSuite) SetupTest() {
|
|
tApp := app.NewTestApp()
|
|
suite.genTime = tmtime.Canonical(time.Date(2021, 1, 1, 1, 1, 1, 1, time.UTC))
|
|
suite.ctx = tApp.NewContext(true, tmproto.Header{Height: 1, Time: suite.genTime})
|
|
suite.keeper = tApp.GetCDPKeeper()
|
|
suite.app = tApp
|
|
|
|
_, addrs := app.GeneratePrivKeyAddressPairs(3)
|
|
suite.addrs = addrs
|
|
}
|
|
|
|
func (suite *GenesisTestSuite) TestInvalidGenState() {
|
|
type args struct {
|
|
params types.Params
|
|
cdps types.CDPs
|
|
deposits types.Deposits
|
|
startingID uint64
|
|
debtDenom string
|
|
govDenom string
|
|
genAccumTimes types.GenesisAccumulationTimes
|
|
genTotalPrincipals types.GenesisTotalPrincipals
|
|
}
|
|
type errArgs struct {
|
|
expectPass bool
|
|
contains string
|
|
}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
args args
|
|
errArgs errArgs
|
|
}{
|
|
{
|
|
name: "empty debt denom",
|
|
args: args{
|
|
params: types.DefaultParams(),
|
|
cdps: types.CDPs{},
|
|
deposits: types.Deposits{},
|
|
debtDenom: "",
|
|
govDenom: types.DefaultGovDenom,
|
|
genAccumTimes: types.DefaultGenesisState().PreviousAccumulationTimes,
|
|
genTotalPrincipals: types.DefaultGenesisState().TotalPrincipals,
|
|
},
|
|
errArgs: errArgs{
|
|
expectPass: false,
|
|
contains: "debt denom invalid",
|
|
},
|
|
},
|
|
{
|
|
name: "empty gov denom",
|
|
args: args{
|
|
params: types.DefaultParams(),
|
|
cdps: types.CDPs{},
|
|
deposits: types.Deposits{},
|
|
debtDenom: types.DefaultDebtDenom,
|
|
govDenom: "",
|
|
genAccumTimes: types.DefaultGenesisState().PreviousAccumulationTimes,
|
|
genTotalPrincipals: types.DefaultGenesisState().TotalPrincipals,
|
|
},
|
|
errArgs: errArgs{
|
|
expectPass: false,
|
|
contains: "gov denom invalid",
|
|
},
|
|
},
|
|
{
|
|
name: "interest factor below one",
|
|
args: args{
|
|
params: types.DefaultParams(),
|
|
cdps: types.CDPs{},
|
|
deposits: types.Deposits{},
|
|
debtDenom: types.DefaultDebtDenom,
|
|
govDenom: types.DefaultGovDenom,
|
|
genAccumTimes: types.GenesisAccumulationTimes{types.NewGenesisAccumulationTime("bnb-a", time.Time{}, sdk.OneDec().Sub(sdk.SmallestDec()))},
|
|
genTotalPrincipals: types.DefaultGenesisState().TotalPrincipals,
|
|
},
|
|
errArgs: errArgs{
|
|
expectPass: false,
|
|
contains: "interest factor should be ≥ 1.0",
|
|
},
|
|
},
|
|
{
|
|
name: "negative total principal",
|
|
args: args{
|
|
params: types.DefaultParams(),
|
|
cdps: types.CDPs{},
|
|
deposits: types.Deposits{},
|
|
debtDenom: types.DefaultDebtDenom,
|
|
govDenom: types.DefaultGovDenom,
|
|
genAccumTimes: types.DefaultGenesisState().PreviousAccumulationTimes,
|
|
genTotalPrincipals: types.GenesisTotalPrincipals{types.NewGenesisTotalPrincipal("bnb-a", sdkmath.NewInt(-1))},
|
|
},
|
|
errArgs: errArgs{
|
|
expectPass: false,
|
|
contains: "total principal should be positive",
|
|
},
|
|
},
|
|
}
|
|
for _, tc := range testCases {
|
|
suite.Run(tc.name, func() {
|
|
gs := types.NewGenesisState(tc.args.params, tc.args.cdps, tc.args.deposits, tc.args.startingID,
|
|
tc.args.debtDenom, tc.args.govDenom, tc.args.genAccumTimes, tc.args.genTotalPrincipals)
|
|
err := gs.Validate()
|
|
if tc.errArgs.expectPass {
|
|
suite.Require().NoError(err)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
suite.Require().True(strings.Contains(err.Error(), tc.errArgs.contains))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *GenesisTestSuite) TestValidGenState() {
|
|
cdc := suite.app.AppCodec()
|
|
|
|
suite.NotPanics(func() {
|
|
suite.app.InitializeFromGenesisStates(
|
|
NewPricefeedGenStateMulti(cdc),
|
|
NewCDPGenStateMulti(cdc),
|
|
)
|
|
})
|
|
|
|
cdpGS := NewCDPGenStateMulti(cdc)
|
|
gs := types.GenesisState{}
|
|
suite.app.AppCodec().MustUnmarshalJSON(cdpGS["cdp"], &gs)
|
|
gs.CDPs = cdps()
|
|
gs.StartingCdpID = uint64(5)
|
|
appGS := app.GenesisState{"cdp": suite.app.AppCodec().MustMarshalJSON(&gs)}
|
|
suite.NotPanics(func() {
|
|
suite.SetupTest()
|
|
suite.app.InitializeFromGenesisStates(
|
|
NewPricefeedGenStateMulti(cdc),
|
|
appGS,
|
|
)
|
|
})
|
|
}
|
|
|
|
func (suite *GenesisTestSuite) Test_InitExportGenesis() {
|
|
cdps := types.CDPs{
|
|
{
|
|
ID: 2,
|
|
Owner: suite.addrs[0],
|
|
Type: "xrp-a",
|
|
Collateral: c("xrp", 200000000),
|
|
Principal: c("usdx", 10000000),
|
|
AccumulatedFees: c("usdx", 0),
|
|
FeesUpdated: suite.genTime,
|
|
InterestFactor: sdk.NewDec(1),
|
|
},
|
|
}
|
|
|
|
genTotalPrincipals := types.GenesisTotalPrincipals{
|
|
types.NewGenesisTotalPrincipal("btc-a", sdk.ZeroInt()),
|
|
types.NewGenesisTotalPrincipal("xrp-a", sdk.ZeroInt()),
|
|
}
|
|
|
|
var deposits types.Deposits
|
|
for _, c := range cdps {
|
|
deposit := types.Deposit{
|
|
CdpID: c.ID,
|
|
Depositor: c.Owner,
|
|
Amount: c.Collateral,
|
|
}
|
|
deposits = append(deposits, deposit)
|
|
|
|
for i, p := range genTotalPrincipals {
|
|
if p.CollateralType == c.Type {
|
|
genTotalPrincipals[i].TotalPrincipal = genTotalPrincipals[i].TotalPrincipal.Add(c.Principal.Amount)
|
|
}
|
|
}
|
|
}
|
|
|
|
cdpGenesis := types.GenesisState{
|
|
Params: types.Params{
|
|
GlobalDebtLimit: sdk.NewInt64Coin("usdx", 1000000000000),
|
|
SurplusAuctionThreshold: types.DefaultSurplusThreshold,
|
|
SurplusAuctionLot: types.DefaultSurplusLot,
|
|
DebtAuctionThreshold: types.DefaultDebtThreshold,
|
|
DebtAuctionLot: types.DefaultDebtLot,
|
|
LiquidationBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval,
|
|
CollateralParams: types.CollateralParams{
|
|
{
|
|
Denom: "xrp",
|
|
Type: "xrp-a",
|
|
LiquidationRatio: sdk.MustNewDecFromStr("2.0"),
|
|
DebtLimit: sdk.NewInt64Coin("usdx", 500000000000),
|
|
StabilityFee: sdk.MustNewDecFromStr("1.000000001547125958"), // 5% apr
|
|
LiquidationPenalty: d("0.05"),
|
|
AuctionSize: i(7000000000),
|
|
SpotMarketID: "xrp:usd",
|
|
LiquidationMarketID: "xrp:usd",
|
|
KeeperRewardPercentage: d("0.01"),
|
|
CheckCollateralizationIndexCount: i(10),
|
|
ConversionFactor: i(6),
|
|
},
|
|
{
|
|
Denom: "btc",
|
|
Type: "btc-a",
|
|
LiquidationRatio: sdk.MustNewDecFromStr("1.5"),
|
|
DebtLimit: sdk.NewInt64Coin("usdx", 500000000000),
|
|
StabilityFee: sdk.MustNewDecFromStr("1.000000000782997609"), // 2.5% apr
|
|
LiquidationPenalty: d("0.025"),
|
|
AuctionSize: i(10000000),
|
|
SpotMarketID: "btc:usd",
|
|
LiquidationMarketID: "btc:usd",
|
|
KeeperRewardPercentage: d("0.01"),
|
|
CheckCollateralizationIndexCount: i(10),
|
|
ConversionFactor: i(8),
|
|
},
|
|
},
|
|
DebtParam: types.DebtParam{
|
|
Denom: "usdx",
|
|
ReferenceAsset: "usd",
|
|
ConversionFactor: i(6),
|
|
DebtFloor: i(10000000),
|
|
},
|
|
},
|
|
StartingCdpID: types.DefaultCdpStartingID,
|
|
DebtDenom: types.DefaultDebtDenom,
|
|
GovDenom: types.DefaultGovDenom,
|
|
CDPs: cdps,
|
|
Deposits: deposits,
|
|
PreviousAccumulationTimes: types.GenesisAccumulationTimes{
|
|
types.NewGenesisAccumulationTime("btc-a", suite.genTime, sdk.OneDec()),
|
|
types.NewGenesisAccumulationTime("xrp-a", suite.genTime, sdk.OneDec()),
|
|
},
|
|
TotalPrincipals: genTotalPrincipals,
|
|
}
|
|
|
|
suite.NotPanics(func() {
|
|
suite.app.InitializeFromGenesisStatesWithTime(
|
|
suite.genTime,
|
|
NewPricefeedGenStateMulti(suite.app.AppCodec()),
|
|
app.GenesisState{types.ModuleName: suite.app.AppCodec().MustMarshalJSON(&cdpGenesis)},
|
|
)
|
|
})
|
|
|
|
// We run the BeginBlocker at time.Now() to accumulate interest
|
|
suite.ctx = suite.ctx.WithBlockTime(time.Now())
|
|
cdp.BeginBlocker(suite.ctx, abci.RequestBeginBlock{}, suite.keeper)
|
|
|
|
expectedGenesis := cdpGenesis
|
|
|
|
// Update previous accrual times in expected genesis
|
|
var expectedPrevAccTimes types.GenesisAccumulationTimes
|
|
for _, prevAccTime := range cdpGenesis.PreviousAccumulationTimes {
|
|
time, found := suite.keeper.GetPreviousAccrualTime(suite.ctx, prevAccTime.CollateralType)
|
|
if !found {
|
|
panic(fmt.Sprintf("couldn't find previous accrual time for %s", prevAccTime.CollateralType))
|
|
}
|
|
prevAccTime.PreviousAccumulationTime = time
|
|
|
|
interestFactor, found := suite.keeper.GetInterestFactor(suite.ctx, prevAccTime.CollateralType)
|
|
if !found {
|
|
panic(fmt.Sprintf("couldn't find interest factor for %s", prevAccTime.CollateralType))
|
|
}
|
|
prevAccTime.InterestFactor = interestFactor
|
|
|
|
expectedPrevAccTimes = append(expectedPrevAccTimes, prevAccTime)
|
|
}
|
|
expectedGenesis.PreviousAccumulationTimes = expectedPrevAccTimes
|
|
|
|
// Update total principals
|
|
var totalPrincipals types.GenesisTotalPrincipals
|
|
for _, p := range expectedGenesis.TotalPrincipals {
|
|
totalPrincipal := suite.keeper.GetTotalPrincipal(suite.ctx, p.CollateralType, "usdx")
|
|
p.TotalPrincipal = totalPrincipal
|
|
totalPrincipals = append(totalPrincipals, p)
|
|
}
|
|
expectedGenesis.TotalPrincipals = totalPrincipals
|
|
|
|
// Update CDPs
|
|
expectedGenesis.CDPs = suite.keeper.GetAllCdps(suite.ctx)
|
|
|
|
exportedGenesis := cdp.ExportGenesis(suite.ctx, suite.keeper)
|
|
|
|
// Sort TotalPrincipals in both genesis files so slice order matches
|
|
sort.SliceStable(expectedGenesis.TotalPrincipals, func(i, j int) bool {
|
|
return expectedGenesis.TotalPrincipals[i].CollateralType < expectedGenesis.TotalPrincipals[j].CollateralType
|
|
})
|
|
sort.SliceStable(exportedGenesis.TotalPrincipals, func(i, j int) bool {
|
|
return exportedGenesis.TotalPrincipals[i].CollateralType < exportedGenesis.TotalPrincipals[j].CollateralType
|
|
})
|
|
|
|
// Sort PreviousAccumulationTimes in both genesis files so slice order matches
|
|
sort.SliceStable(expectedGenesis.PreviousAccumulationTimes, func(i, j int) bool {
|
|
return expectedGenesis.PreviousAccumulationTimes[i].CollateralType < expectedGenesis.PreviousAccumulationTimes[j].CollateralType
|
|
})
|
|
sort.SliceStable(exportedGenesis.PreviousAccumulationTimes, func(i, j int) bool {
|
|
return exportedGenesis.PreviousAccumulationTimes[i].CollateralType < exportedGenesis.PreviousAccumulationTimes[j].CollateralType
|
|
})
|
|
|
|
suite.Equal(expectedGenesis, exportedGenesis)
|
|
}
|
|
|
|
func TestGenesisTestSuite(t *testing.T) {
|
|
suite.Run(t, new(GenesisTestSuite))
|
|
}
|