diff --git a/app/app.go b/app/app.go index 75c303da8..9d5223c92 100644 --- a/app/app.go +++ b/app/app.go @@ -198,7 +198,7 @@ import ( cwasm "github.com/comdex-official/comdex/app/wasm" - mv12 "github.com/comdex-official/comdex/app/upgrades/mainnet/v12" + mv13 "github.com/comdex-official/comdex/app/upgrades/mainnet/v13" tv13 "github.com/comdex-official/comdex/app/upgrades/testnet/v13" ) @@ -1456,8 +1456,8 @@ func (a *App) ModuleAccountsPermissions() map[string][]string { func (a *App) registerUpgradeHandlers() { a.UpgradeKeeper.SetUpgradeHandler( - tv13.UpgradeName, - tv13.CreateUpgradeHandlerV13(a.mm, a.configurator, a.cdc, a.keys[capabilitytypes.ModuleName], a.CapabilityKeeper, a.WasmKeeper, a.ParamsKeeper, a.ConsensusParamsKeeper, *a.IbcKeeper, a.GovKeeper, *a.StakingKeeper, a.MintKeeper, a.SlashingKeeper, a.BandoracleKeeper), + mv13.UpgradeName, + mv13.CreateUpgradeHandlerV13(a.mm, a.configurator, a.cdc, a.ParamsKeeper, a.ConsensusParamsKeeper, *a.IbcKeeper, a.ICQKeeper, a.GovKeeper, a.AssetKeeper, a.LendKeeper, a.NewliqKeeper, a.NewaucKeeper), ) // When a planned update height is reached, the old binary will panic // writing on disk the height and name of the update that triggered it @@ -1480,12 +1480,15 @@ func (a *App) registerUpgradeHandlers() { func upgradeHandlers(upgradeInfo upgradetypes.Plan, a *App, storeUpgrades *storetypes.StoreUpgrades) *storetypes.StoreUpgrades { switch { - case upgradeInfo.Name == mv12.UpgradeName && !a.UpgradeKeeper.IsSkipHeight(upgradeInfo.Height): + case upgradeInfo.Name == mv13.UpgradeName && !a.UpgradeKeeper.IsSkipHeight(upgradeInfo.Height): storeUpgrades = &storetypes.StoreUpgrades{ Added: []string{ icqtypes.StoreKey, liquidationsV2types.ModuleName, auctionsV2types.ModuleName, + crisistypes.StoreKey, + consensusparamtypes.StoreKey, + ibcfeetypes.StoreKey, }, } case upgradeInfo.Name == tv13.UpgradeName && !a.UpgradeKeeper.IsSkipHeight(upgradeInfo.Height): diff --git a/app/upgrades/mainnet/v13/constants.go b/app/upgrades/mainnet/v13/constants.go new file mode 100644 index 000000000..26bd30d5c --- /dev/null +++ b/app/upgrades/mainnet/v13/constants.go @@ -0,0 +1,15 @@ +package v13 + +const ( + UpgradeName = "v13.2.0" + UpgradeHeight = "" + UpgradeInfo = `'{ + "binaries": { + "darwin/arm64":"", + "darwin/x86_64":"", + "linux/arm64":"", + "linux/x86_64":"", + "windows/x86_64":"" + } + }'` +) diff --git a/app/upgrades/mainnet/v13/upgrade_test.go b/app/upgrades/mainnet/v13/upgrade_test.go new file mode 100644 index 000000000..41fe9e288 --- /dev/null +++ b/app/upgrades/mainnet/v13/upgrade_test.go @@ -0,0 +1,45 @@ +package v13_test + +import ( + "testing" + + "github.com/stretchr/testify/suite" + + "github.com/comdex-official/comdex/app" + v13 "github.com/comdex-official/comdex/app/upgrades/mainnet/v13" +) + +type UpgradeTestSuite struct { + app.KeeperTestHelper +} + +func (s *UpgradeTestSuite) SetupTest() { + s.Setup() +} + +func TestKeeperTestSuite(t *testing.T) { + suite.Run(t, new(UpgradeTestSuite)) +} + +// Ensures the test does not error out. +func (s *UpgradeTestSuite) TestUpgrade() { + s.Setup() + + preUpgradeChecks(s) + + upgradeHeight := int64(5) + s.ConfirmUpgradeSucceeded(v13.UpgradeName, upgradeHeight) + + postUpgradeChecks(s) +} + +func preUpgradeChecks(s *UpgradeTestSuite) { + +} + +func postUpgradeChecks(s *UpgradeTestSuite) { + + // Ensure the gov params have MinInitialDepositRatio added + gp := s.App.GovKeeper.GetParams(s.Ctx) + s.Require().Equal(gp.MinInitialDepositRatio, "0.200000000000000000") +} diff --git a/app/upgrades/mainnet/v13/upgrades.go b/app/upgrades/mainnet/v13/upgrades.go new file mode 100644 index 000000000..02d1350e0 --- /dev/null +++ b/app/upgrades/mainnet/v13/upgrades.go @@ -0,0 +1,233 @@ +package v13 + +import ( + "fmt" + assetkeeper "github.com/comdex-official/comdex/x/asset/keeper" + assettypes "github.com/comdex-official/comdex/x/asset/types" + auctionV2keeper "github.com/comdex-official/comdex/x/auctionsV2/keeper" + auctionsV2types "github.com/comdex-official/comdex/x/auctionsV2/types" + lendkeeper "github.com/comdex-official/comdex/x/lend/keeper" + lendtypes "github.com/comdex-official/comdex/x/lend/types" + liquidationV2keeper "github.com/comdex-official/comdex/x/liquidationsV2/keeper" + liquidationV2types "github.com/comdex-official/comdex/x/liquidationsV2/types" + "github.com/cosmos/cosmos-sdk/baseapp" + "github.com/cosmos/cosmos-sdk/codec" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + consensusparamkeeper "github.com/cosmos/cosmos-sdk/x/consensus/keeper" + govkeeper "github.com/cosmos/cosmos-sdk/x/gov/keeper" + paramskeeper "github.com/cosmos/cosmos-sdk/x/params/keeper" + paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" + upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types" + icqkeeper "github.com/cosmos/ibc-apps/modules/async-icq/v7/keeper" + icqtypes "github.com/cosmos/ibc-apps/modules/async-icq/v7/types" + exported "github.com/cosmos/ibc-go/v7/modules/core/exported" + ibckeeper "github.com/cosmos/ibc-go/v7/modules/core/keeper" + ibctmmigrations "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint/migrations" +) + +func CreateUpgradeHandlerV13( + mm *module.Manager, + configurator module.Configurator, + cdc codec.Codec, + paramsKeeper paramskeeper.Keeper, + consensusParamsKeeper consensusparamkeeper.Keeper, + IBCKeeper ibckeeper.Keeper, + icqkeeper *icqkeeper.Keeper, + GovKeeper govkeeper.Keeper, + assetKeeper assetkeeper.Keeper, + lendKeeper lendkeeper.Keeper, + liquidationV2Keeper liquidationV2keeper.Keeper, + auctionV2Keeper auctionV2keeper.Keeper, +) upgradetypes.UpgradeHandler { + return func(ctx sdk.Context, _ upgradetypes.Plan, fromVM module.VersionMap) (module.VersionMap, error) { + ctx.Logger().Info("Applying main net upgrade - v.13.2.0") + logger := ctx.Logger().With("upgrade", UpgradeName) + + // Migrate Tendermint consensus parameters from x/params module to a deprecated x/consensus module. + // The old params module is required to still be imported in your app.go in order to handle this migration. + ctx.Logger().Info("Migrating tendermint consensus params from x/params to x/consensus...") + legacyParamSubspace := paramsKeeper.Subspace(baseapp.Paramspace).WithKeyTable(paramstypes.ConsensusParamsKeyTable()) + baseapp.MigrateParams(ctx, legacyParamSubspace, &consensusParamsKeeper) + + // ibc v4-to-v5 + // https://github.com/cosmos/ibc-go/blob/v7.1.0/docs/migrations/v4-to-v5.md + // -- nothing -- + + // https://github.com/cosmos/ibc-go/blob/v7.1.0/docs/migrations/v5-to-v6.md + + // ibc v6-to-v7 + // https://github.com/cosmos/ibc-go/blob/v7.1.0/docs/migrations/v6-to-v7.md#chains + // (optional) prune expired tendermint consensus states to save storage space + ctx.Logger().Info("Pruning expired tendermint consensus states...") + if _, err := ibctmmigrations.PruneExpiredConsensusStates(ctx, cdc, IBCKeeper.ClientKeeper); err != nil { + return nil, err + } + + // ibc v7-to-v7.1 + // https://github.com/cosmos/ibc-go/blob/v7.1.0/docs/migrations/v7-to-v7_1.md#09-localhost-migration + // explicitly update the IBC 02-client params, adding the localhost client type + params := IBCKeeper.ClientKeeper.GetParams(ctx) + params.AllowedClients = append(params.AllowedClients, exported.Localhost) + IBCKeeper.ClientKeeper.SetParams(ctx, params) + logger.Info(fmt.Sprintf("updated ibc client params %v", params)) + + // icq params set + icqparams := icqtypes.DefaultParams() + icqparams.AllowQueries = append(icqparams.AllowQueries, "/cosmwasm.wasm.v1.Query/SmartContractState") + icqkeeper.SetParams(ctx, icqparams) + + // Run migrations + logger.Info(fmt.Sprintf("pre migrate version map: %v", fromVM)) + vm, err := mm.RunMigrations(ctx, configurator, fromVM) + if err != nil { + return nil, err + } + logger.Info(fmt.Sprintf("post migrate version map: %v", vm)) + + // update gov params to use a 20% initial deposit ratio, allowing us to remote the ante handler + govParams := GovKeeper.GetParams(ctx) + govParams.MinInitialDepositRatio = sdk.NewDec(20).Quo(sdk.NewDec(100)).String() + if err := GovKeeper.SetParams(ctx, govParams); err != nil { + return nil, err + } + logger.Info(fmt.Sprintf("updated gov params to %v", govParams)) + + UpdateLendParams(ctx, lendKeeper, assetKeeper) + InitializeStates(ctx, liquidationV2Keeper, auctionV2Keeper) + + return vm, err + } +} + +func UpdateLendParams( + ctx sdk.Context, + lendKeeper lendkeeper.Keeper, + assetKeeper assetkeeper.Keeper, +) { + + cSTATOM := assettypes.Asset{ + Name: "CSTATOM", + Denom: "ucstatom", + Decimals: sdk.NewInt(1000000), + IsOnChain: true, + IsOraclePriceRequired: false, + IsCdpMintable: true, + } + err := assetKeeper.AddAssetRecords(ctx, cSTATOM) + if err != nil { + fmt.Println(err) + } + assetID := assetKeeper.GetAssetID(ctx) + + assetRatesParamsSTAtom := lendtypes.AssetRatesParams{ + AssetID: 14, + UOptimal: newDec("0.75"), + Base: newDec("0.002"), + Slope1: newDec("0.07"), + Slope2: newDec("1.25"), + EnableStableBorrow: false, + Ltv: newDec("0.7"), + LiquidationThreshold: newDec("0.75"), + LiquidationPenalty: newDec("0.05"), + LiquidationBonus: newDec("0.05"), + ReserveFactor: newDec("0.2"), + CAssetID: assetID, + IsIsolated: false, + } + lendKeeper.SetAssetRatesParams(ctx, assetRatesParamsSTAtom) + + assetRatesParamsCmdx, _ := lendKeeper.GetAssetRatesParams(ctx, 2) + assetRatesParamsCmdx.LiquidationPenalty = newDec("0.075") + assetRatesParamsCmdx.LiquidationBonus = newDec("0.075") + lendKeeper.SetAssetRatesParams(ctx, assetRatesParamsCmdx) + + assetRatesParamsCmst, _ := lendKeeper.GetAssetRatesParams(ctx, 3) + assetRatesParamsCmst.LiquidationPenalty = newDec("0.05") + assetRatesParamsCmst.LiquidationBonus = newDec("0.05") + lendKeeper.SetAssetRatesParams(ctx, assetRatesParamsCmst) + + cAXLUSDC := assettypes.Asset{ + Name: "CAXLUSDC", + Denom: "ucaxlusdc", + Decimals: sdk.NewInt(1000000), + IsOnChain: true, + IsOraclePriceRequired: false, + IsCdpMintable: true, + } + err = assetKeeper.AddAssetRecords(ctx, cAXLUSDC) + if err != nil { + fmt.Println(err) + } +} + +func InitializeStates( + ctx sdk.Context, + liquidationKeeper liquidationV2keeper.Keeper, + auctionKeeper auctionV2keeper.Keeper, +) { + dutchAuctionParams := liquidationV2types.DutchAuctionParam{ + Premium: newDec("1.15"), + Discount: newDec("0.7"), + DecrementFactor: sdk.NewInt(1), + } + englishAuctionParams := liquidationV2types.EnglishAuctionParam{DecrementFactor: sdk.NewInt(1)} + + harborParams := liquidationV2types.LiquidationWhiteListing{ + AppId: 2, + Initiator: true, + IsDutchActivated: true, + DutchAuctionParam: &dutchAuctionParams, + IsEnglishActivated: true, + EnglishAuctionParam: &englishAuctionParams, + KeeeperIncentive: sdk.ZeroDec(), + } + + commodoParams := liquidationV2types.LiquidationWhiteListing{ + AppId: 3, + Initiator: true, + IsDutchActivated: true, + DutchAuctionParam: &dutchAuctionParams, + IsEnglishActivated: false, + EnglishAuctionParam: nil, + KeeeperIncentive: sdk.ZeroDec(), + } + + liquidationKeeper.SetLiquidationWhiteListing(ctx, harborParams) + liquidationKeeper.SetLiquidationWhiteListing(ctx, commodoParams) + + appReserveFundsTxDataHbr, found := liquidationKeeper.GetAppReserveFundsTxData(ctx, 2) + if !found { + appReserveFundsTxDataHbr.AppId = 2 + } + appReserveFundsTxDataHbr.AssetTxData = append(appReserveFundsTxDataHbr.AssetTxData, liquidationV2types.AssetTxData{}) + liquidationKeeper.SetAppReserveFundsTxData(ctx, appReserveFundsTxDataHbr) + + appReserveFundsTxDataCmdo, found := liquidationKeeper.GetAppReserveFundsTxData(ctx, 3) + if !found { + appReserveFundsTxDataCmdo.AppId = 3 + } + appReserveFundsTxDataCmdo.AssetTxData = append(appReserveFundsTxDataCmdo.AssetTxData, liquidationV2types.AssetTxData{}) + liquidationKeeper.SetAppReserveFundsTxData(ctx, appReserveFundsTxDataCmdo) + + auctionParams := auctionsV2types.AuctionParams{ + AuctionDurationSeconds: 18000, + Step: newDec("0.1"), + WithdrawalFee: newDec("0.0005"), + ClosingFee: newDec("0.0005"), + MinUsdValueLeft: 100000, + BidFactor: newDec("0.01"), + LiquidationPenalty: newDec("0.1"), + AuctionBonus: newDec("0.0"), + } + auctionKeeper.SetAuctionParams(ctx, auctionParams) + auctionKeeper.SetParams(ctx, auctionsV2types.Params{}) + auctionKeeper.SetAuctionID(ctx, 0) + auctionKeeper.SetUserBidID(ctx, 0) + +} + +func newDec(i string) sdk.Dec { + dec, _ := sdk.NewDecFromStr(i) + return dec +} diff --git a/app/upgrades/testnet/v13/upgrade_test.go b/app/upgrades/testnet/v13/upgrade_test.go index be9f1a70f..41cbb1b72 100644 --- a/app/upgrades/testnet/v13/upgrade_test.go +++ b/app/upgrades/testnet/v13/upgrade_test.go @@ -1,64 +1,64 @@ package v13_test -import ( - "testing" +// import ( +// "testing" - "github.com/stretchr/testify/suite" +// "github.com/stretchr/testify/suite" - "github.com/comdex-official/comdex/app" - wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types" - v13 "github.com/comdex-official/comdex/app/upgrades/testnet/v13" -) +// "github.com/comdex-official/comdex/app" +// wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types" +// v13 "github.com/comdex-official/comdex/app/upgrades/testnet/v13" +// ) -type UpgradeTestSuite struct { - app.KeeperTestHelper -} +// type UpgradeTestSuite struct { +// app.KeeperTestHelper +// } -func (s *UpgradeTestSuite) SetupTest() { - s.Setup() -} +// func (s *UpgradeTestSuite) SetupTest() { +// s.Setup() +// } -func TestKeeperTestSuite(t *testing.T) { - suite.Run(t, new(UpgradeTestSuite)) -} +// func TestKeeperTestSuite(t *testing.T) { +// suite.Run(t, new(UpgradeTestSuite)) +// } -// Ensures the test does not error out. -func (s *UpgradeTestSuite) TestUpgrade() { - s.Setup() +// // Ensures the test does not error out. +// func (s *UpgradeTestSuite) TestUpgrade() { +// s.Setup() - preUpgradeChecks(s) +// preUpgradeChecks(s) - upgradeHeight := int64(5) - s.ConfirmUpgradeSucceeded(v13.UpgradeName, upgradeHeight) +// upgradeHeight := int64(5) +// s.ConfirmUpgradeSucceeded(v13.UpgradeName, upgradeHeight) - postUpgradeChecks(s) -} +// postUpgradeChecks(s) +// } -func preUpgradeChecks(s *UpgradeTestSuite) { +// func preUpgradeChecks(s *UpgradeTestSuite) { - mp := s.App.MintKeeper.GetParams(s.Ctx) - s.Require().Equal(mp.BlocksPerYear, uint64(6311520)) +// mp := s.App.MintKeeper.GetParams(s.Ctx) +// s.Require().Equal(mp.BlocksPerYear, uint64(6311520)) - sp := s.App.SlashingKeeper.GetParams(s.Ctx) - s.Require().Equal(sp.SignedBlocksWindow, int64(100)) +// sp := s.App.SlashingKeeper.GetParams(s.Ctx) +// s.Require().Equal(sp.SignedBlocksWindow, int64(100)) -} +// } -func postUpgradeChecks(s *UpgradeTestSuite) { +// func postUpgradeChecks(s *UpgradeTestSuite) { - // Ensure the gov params have MinInitialDepositRatio added - gp := s.App.GovKeeper.GetParams(s.Ctx) - s.Require().Equal(gp.MinInitialDepositRatio, "0.200000000000000000") +// // Ensure the gov params have MinInitialDepositRatio added +// gp := s.App.GovKeeper.GetParams(s.Ctx) +// s.Require().Equal(gp.MinInitialDepositRatio, "0.200000000000000000") - // Ensure the mint params have doubled - mp := s.App.MintKeeper.GetParams(s.Ctx) - s.Require().Equal(mp.BlocksPerYear, uint64(6311520*2)) +// // Ensure the mint params have doubled +// mp := s.App.MintKeeper.GetParams(s.Ctx) +// s.Require().Equal(mp.BlocksPerYear, uint64(6311520*2)) - // Ensure the slashing params have doubled - sp := s.App.SlashingKeeper.GetParams(s.Ctx) - s.Require().Equal(sp.SignedBlocksWindow, int64(100*2)) +// // Ensure the slashing params have doubled +// sp := s.App.SlashingKeeper.GetParams(s.Ctx) +// s.Require().Equal(sp.SignedBlocksWindow, int64(100*2)) - // Ensure the wasm Permissionless - wp := s.App.WasmKeeper.GetParams(s.Ctx) - s.Require().Equal(wp.CodeUploadAccess, wasmtypes.AllowEverybody) -} +// // Ensure the wasm Permissionless +// wp := s.App.WasmKeeper.GetParams(s.Ctx) +// s.Require().Equal(wp.CodeUploadAccess, wasmtypes.AllowEverybody) +// } diff --git a/cmd/comdex/root.go b/cmd/comdex/root.go index edae184a6..6dbdaa3dd 100644 --- a/cmd/comdex/root.go +++ b/cmd/comdex/root.go @@ -5,7 +5,7 @@ import ( "io" "os" "path/filepath" - "time" + // "time" "github.com/CosmWasm/wasmd/x/wasm" wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper" @@ -76,13 +76,13 @@ func NewRootCmd() (*cobra.Command, comdex.EncodingConfig) { return err } // 2 seconds + 1 second tendermint = 3 second blocks - timeoutCommit := 2 * time.Second + // timeoutCommit := 2 * time.Second customAppTemplate, customAppConfig := initAppConfig() - customTMConfig := initTendermintConfig(timeoutCommit) + customTMConfig := initTendermintConfig() // Force faster block times - os.Setenv("COMDEX_CONSENSUS_TIMEOUT_COMMIT", cast.ToString(timeoutCommit)) + // os.Setenv("COMDEX_CONSENSUS_TIMEOUT_COMMIT", cast.ToString(timeoutCommit)) return server.InterceptConfigsPreRunHandler(cmd, customAppTemplate, customAppConfig, customTMConfig) }, @@ -92,7 +92,7 @@ func NewRootCmd() (*cobra.Command, comdex.EncodingConfig) { return root, encodingConfig } -func initTendermintConfig(timeoutCommit time.Duration) *tmcfg.Config { +func initTendermintConfig() *tmcfg.Config { cfg := tmcfg.DefaultConfig() // these values put a higher strain on node memory @@ -100,7 +100,7 @@ func initTendermintConfig(timeoutCommit time.Duration) *tmcfg.Config { // cfg.P2P.MaxNumOutboundPeers = 40 // While this is set, it only applies to new configs. - cfg.Consensus.TimeoutCommit = timeoutCommit + // cfg.Consensus.TimeoutCommit = timeoutCommit return cfg } diff --git a/x/auctionsV2/keeper/bid.go b/x/auctionsV2/keeper/bid.go index ac1fc3139..c8294ce95 100644 --- a/x/auctionsV2/keeper/bid.go +++ b/x/auctionsV2/keeper/bid.go @@ -24,7 +24,10 @@ func (k Keeper) PlaceDutchAuctionBid(ctx sdk.Context, auctionID uint64, bidder s if bid.Denom != auctionData.DebtToken.Denom { return bidId, types.ErrorUnknownDebtToken } - liquidationData, _ := k.LiquidationsV2.GetLockedVault(ctx, auctionData.AppId, auctionData.LockedVaultId) + liquidationData, found := k.LiquidationsV2.GetLockedVault(ctx, auctionData.AppId, auctionData.LockedVaultId) + if !found { + return 0, types.ErrorInGettingLockedVault + } //Price data of the token from market module debtToken, _ := k.market.GetTwa(ctx, auctionData.DebtAssetId) debtPrice := sdk.NewDecFromInt(sdk.NewInt(int64(debtToken.Twa))) @@ -163,7 +166,7 @@ func (k Keeper) PlaceDutchAuctionBid(ctx sdk.Context, auctionID uint64, bidder s if keeperIncentive.GT(sdk.ZeroInt()) { liquidationPenalty = liquidationPenalty.Sub(sdk.NewCoin(auctionData.DebtToken.Denom, keeperIncentive)) addr, _ := sdk.AccAddressFromBech32(liquidationData.InternalKeeperAddress) - err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, auctionsV2types.ModuleName, addr, sdk.NewCoins(sdk.NewCoin(auctionData.DebtToken.Denom, keeperIncentive))) + err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, auctionsV2types.ModuleName, addr, sdk.NewCoins(sdk.NewCoin(auctionData.DebtToken.Denom, keeperIncentive))) if err != nil { return bidId, err } diff --git a/x/auctionsV2/types/errors.go b/x/auctionsV2/types/errors.go index 8cfad6775..6bc42a077 100644 --- a/x/auctionsV2/types/errors.go +++ b/x/auctionsV2/types/errors.go @@ -23,4 +23,5 @@ var ( ErrorDiscountGreaterThanMaxDiscount = sdkerrors.Register(ModuleName, 713, "Premium discount entered is greater than max discount") ErrAuctionLookupTableNotFound = sdkerrors.Register(ModuleName, 714, "auctionLookupTable not found") ErrorUnableToSetNetFees = sdkerrors.Register(ModuleName, 715, "Unable To set net fees collected after auction closed") + ErrorInGettingLockedVault = sdkerrors.Register(ModuleName, 716, "error in bid dutch auction - locked vault not found") ) diff --git a/x/bandoracle/abci.go b/x/bandoracle/abci.go index 270093bc0..5b80f7e63 100644 --- a/x/bandoracle/abci.go +++ b/x/bandoracle/abci.go @@ -14,8 +14,8 @@ func BeginBlocker(ctx sdk.Context, _ abci.RequestBeginBlock, k keeper.Keeper) { block := k.GetLastBlockHeight(ctx) if block != types.Int64Zero { - // if ctx.BlockHeight()%types.Int64Forty == types.Int64Zero && ctx.BlockHeight() != block { - if ctx.BlockHeight()%types.Int64Forty == types.Int64Zero { + // if ctx.BlockHeight()%types.Int64Twenty == types.Int64Zero && ctx.BlockHeight() != block { + if ctx.BlockHeight()%types.Int64Twenty == types.Int64Zero { if !k.GetCheckFlag(ctx) { msg := k.GetFetchPriceMsg(ctx) _, err := k.FetchPrice(ctx, msg) diff --git a/x/lend/keeper/keeper.go b/x/lend/keeper/keeper.go index ff09f8d0c..a2f14e8e2 100644 --- a/x/lend/keeper/keeper.go +++ b/x/lend/keeper/keeper.go @@ -1633,7 +1633,7 @@ func (k Keeper) RemoveFaultyAuctions(ctx sdk.Context) error { //send debt from reserve to the pool err := k.bank.SendCoinsFromModuleToModule(ctx, reserveModuleName, cPoolModuleName, sdk.NewCoins(dutchAuction.InflowTokenTargetAmount)) if err != nil { - return err + continue } //send collateral to the reserve from auction module outflow_token_current_amount err = k.bank.SendCoinsFromModuleToModule(ctx, auctiontypes.ModuleName, reserveModuleName, sdk.NewCoins(dutchAuction.OutflowTokenCurrentAmount)) diff --git a/x/market/abci.go b/x/market/abci.go index 4cfdfdc47..f94063ab3 100644 --- a/x/market/abci.go +++ b/x/market/abci.go @@ -17,8 +17,8 @@ func BeginBlocker(ctx sdk.Context, _ abci.RequestBeginBlock, k keeper.Keeper, ba if bandKeeper.GetOracleValidationResult(ctx) { block := bandKeeper.GetLastBlockHeight(ctx) if block != types.Int64Zero { - // if ctx.BlockHeight()%types.Int64Forty == types.Int64Zero && ctx.BlockHeight() != block && bandKeeper.GetCheckFlag(ctx) { - if ctx.BlockHeight()%types.Int64Forty == types.Int64Zero { + // if ctx.BlockHeight()%types.Int64Twenty == types.Int64Zero && ctx.BlockHeight() != block && bandKeeper.GetCheckFlag(ctx) { + if ctx.BlockHeight()%types.Int64Twenty == types.Int64Zero { discardData := bandKeeper.GetDiscardData(ctx) if discardData.DiscardBool { allTwa := k.GetAllTwa(ctx)