From c59a491788df2563baf3f1487f265fad94711681 Mon Sep 17 00:00:00 2001 From: Levi Schoen Date: Fri, 2 Feb 2024 08:21:11 -1000 Subject: [PATCH] feat(x/cdp): update begin bloocker to run liquidations every X blocks based off params (#1818) * (feat) update x/cdp to run every X blocks based off params (#1814) * add new cdp module param to protonet genesis * update cdp / cdp related tests for new module param * update telemetry docs and setup for collecting against local node * update kvool commit for new cdp param (cherry picked from commit 4d62f4777314348515bf84451587f1e25b93c6e8) * add tests for configurable x/cdp begin blocker interval param add migration for default value of param * make adjustments based off pr feedback * fix proto back compat check --- CHANGELOG.md | 4 +- Makefile | 1 + ci/env/kava-protonet/genesis.json | 1 + client/docs/swagger-ui/swagger.yaml | 9 + docs/Telemetry.md | 8 +- docs/core/proto-docs.md | 1 + prometheus.docker-compose.yml | 7 + prometheus.yml | 3 +- proto/kava/cdp/v1beta1/genesis.proto | 2 + tests/e2e/kvtool | 2 +- x/cdp/abci.go | 11 + x/cdp/abci_test.go | 114 ++++++++ x/cdp/genesis_test.go | 11 +- x/cdp/integration_test.go | 11 +- x/cdp/keeper/integration_test.go | 33 ++- x/cdp/keeper/migrations.go | 23 ++ x/cdp/keeper/params.go | 2 +- x/cdp/legacy/v0_15/types.go | 109 -------- x/cdp/legacy/v0_16/migrate.go | 109 -------- x/cdp/legacy/v0_16/migrate_test.go | 216 --------------- x/cdp/legacy/v0_16/testdata/v15-cdp.json | 135 --------- x/cdp/legacy/v0_16/testdata/v16-cdp.json | 93 ------- x/cdp/migrations/v2/store.go | 22 ++ x/cdp/migrations/v2/store_test.go | 63 +++++ x/cdp/module.go | 11 +- x/cdp/types/genesis.pb.go | 203 ++++++++------ x/cdp/types/params.go | 66 +++-- x/cdp/types/params_test.go | 335 +++++++++++++---------- x/community/testutil/cdp_genesis.go | 11 +- x/incentive/integration_test.go | 11 +- x/incentive/keeper/integration_test.go | 11 +- 31 files changed, 682 insertions(+), 956 deletions(-) create mode 100644 x/cdp/keeper/migrations.go delete mode 100644 x/cdp/legacy/v0_15/types.go delete mode 100644 x/cdp/legacy/v0_16/migrate.go delete mode 100644 x/cdp/legacy/v0_16/migrate_test.go delete mode 100644 x/cdp/legacy/v0_16/testdata/v15-cdp.json delete mode 100644 x/cdp/legacy/v0_16/testdata/v16-cdp.json create mode 100644 x/cdp/migrations/v2/store.go create mode 100644 x/cdp/migrations/v2/store_test.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 60a64eae..feaea393 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -39,6 +39,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ ### Features - (cli) [#1785] Add `shard` CLI command to support creating partitions of data for standalone nodes +- (cdp) [#1818] Add module param and logic for running x/cdp begin blocker every `n` blocks - (cli) [#1804] Add `rocksdb compact` command for manual DB compaction of state or blockstore. ## [v0.25.0] @@ -69,6 +70,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ ## [v0.24.3] ### Bug Fixes + - (deps) [#1770] Bump ledger-cosmos-go to v0.13.1 to resolve signing error with - (rocksdb) [#1767] Fix resolution of rocksdb database path introduced in v0.24.2 @@ -324,7 +326,6 @@ the [changelog](https://github.com/cosmos/cosmos-sdk/blob/v0.38.4/CHANGELOG.md). [#1804]: https://github.com/Kava-Labs/kava/pull/1804 [#1785]: https://github.com/Kava-Labs/kava/pull/1785 [#1784]: https://github.com/Kava-Labs/kava/pull/1784 -[#1776]: https://github.com/Kava-Labs/kava/pull/1776 [#1770]: https://github.com/Kava-Labs/kava/pull/1770 [#1755]: https://github.com/Kava-Labs/kava/pull/1755 [#1761]: https://github.com/Kava-Labs/kava/pull/1761 @@ -384,7 +385,6 @@ the [changelog](https://github.com/cosmos/cosmos-sdk/blob/v0.38.4/CHANGELOG.md). [v0.24.1]: https://github.com/Kava-Labs/kava/compare/v0.24.1...v0.24.0 [v0.24.0]: https://github.com/Kava-Labs/kava/compare/v0.24.0...v0.23.2 [v0.23.2]: https://github.com/Kava-Labs/kava/compare/v0.23.1...v0.23.2 -[v0.23.1]: https://github.com/Kava-Labs/kava/compare/v0.23.0...v0.23.1 [v0.23.0]: https://github.com/Kava-Labs/kava/compare/v0.21.1...v0.23.0 [v0.16.1]: https://github.com/Kava-Labs/kava/compare/v0.16.0...v0.16.1 [v0.16.0]: https://github.com/Kava-Labs/kava/compare/v0.15.2...v0.16.0 diff --git a/Makefile b/Makefile index 89673518..1d11e06a 100644 --- a/Makefile +++ b/Makefile @@ -330,6 +330,7 @@ start-remote-sims: -—container-override environment=[{SIM_NAME=master-$(VERSION)}] update-kvtool: + git submodule init || true git submodule update cd tests/e2e/kvtool && make install diff --git a/ci/env/kava-protonet/genesis.json b/ci/env/kava-protonet/genesis.json index 3f55b66a..8e3e0ead 100644 --- a/ci/env/kava-protonet/genesis.json +++ b/ci/env/kava-protonet/genesis.json @@ -837,6 +837,7 @@ "gov_denom": "ukava", "params": { "circuit_breaker": false, + "liquidation_block_interval": 500, "collateral_params": [ { "auction_size": "50000000000", diff --git a/client/docs/swagger-ui/swagger.yaml b/client/docs/swagger-ui/swagger.yaml index f74931ab..bd24127c 100644 --- a/client/docs/swagger-ui/swagger.yaml +++ b/client/docs/swagger-ui/swagger.yaml @@ -3505,6 +3505,9 @@ paths: type: string circuit_breaker: type: boolean + liquidation_block_interval: + type: string + format: int64 description: Params defines the parameters for the cdp module. description: >- QueryParamsResponse defines the response type for the Query/Params @@ -51628,6 +51631,9 @@ definitions: type: string circuit_breaker: type: boolean + liquidation_block_interval: + type: string + format: int64 description: Params defines the parameters for the cdp module. kava.cdp.v1beta1.QueryAccountsResponse: type: object @@ -52161,6 +52167,9 @@ definitions: type: string circuit_breaker: type: boolean + liquidation_block_interval: + type: string + format: int64 description: Params defines the parameters for the cdp module. description: >- QueryParamsResponse defines the response type for the Query/Params RPC diff --git a/docs/Telemetry.md b/docs/Telemetry.md index 72de8873..8df75e5f 100644 --- a/docs/Telemetry.md +++ b/docs/Telemetry.md @@ -38,10 +38,10 @@ Then restart the service with the updated settings ## Running local prometheus collector and grafana services -To collect app metrics and visualize them locally, you can run the prometheus collector and grafana services with docker compose from the repo root directory +To collect app metrics and visualize them locally, you can run the prometheus collector and grafana services with docker compose from the repo root directory (after updating `config.toml` and `app.toml` as detailed above) ```bash -docker compose -f prometheus.docker-compose.yml +docker compose -f prometheus.docker-compose.yml up ``` Navigate to localhost:3000 to view the grafana unix @@ -54,13 +54,13 @@ See [grafana docs](https://grafana.com/docs/grafana/latest/dashboards/) for info ### Collecting from local host -Update [prometheus config](../prometheus.yml) to collect metrics from your local source +Update [prometheus config](../prometheus.yml) to collect metrics from your local source, where the port matches the value set for `config.toml/instrumentation.prometheus_listen_addr` ```yaml metrics_path: / static_configs: - targets: - - localhost:8888 + - docker-host:8888 ``` ### Collecting from remote host diff --git a/docs/core/proto-docs.md b/docs/core/proto-docs.md index e9a3ab15..82b35968 100644 --- a/docs/core/proto-docs.md +++ b/docs/core/proto-docs.md @@ -1681,6 +1681,7 @@ Params defines the parameters for the cdp module. | `debt_auction_threshold` | [string](#string) | | | | `debt_auction_lot` | [string](#string) | | | | `circuit_breaker` | [bool](#bool) | | | +| `liquidation_block_interval` | [int64](#int64) | | | diff --git a/prometheus.docker-compose.yml b/prometheus.docker-compose.yml index f4cf8575..3aa8dceb 100644 --- a/prometheus.docker-compose.yml +++ b/prometheus.docker-compose.yml @@ -34,3 +34,10 @@ services: - 9090 networks: - monitoring + docker-host: + image: qoomon/docker-host + cap_add: [ 'NET_ADMIN', 'NET_RAW' ] + mem_limit: 8M + restart: on-failure + networks: + - monitoring diff --git a/prometheus.yml b/prometheus.yml index d0419b58..b0a1e747 100644 --- a/prometheus.yml +++ b/prometheus.yml @@ -3,8 +3,7 @@ global: evaluation_interval: 15s scrape_configs: - job_name: proxy - scheme: https metrics_path: / static_configs: - targets: - - 4efb-18-207-102-158.ngrok-free.app + - docker-host:8888 diff --git a/proto/kava/cdp/v1beta1/genesis.proto b/proto/kava/cdp/v1beta1/genesis.proto index 3d91aaa4..241d385b 100644 --- a/proto/kava/cdp/v1beta1/genesis.proto +++ b/proto/kava/cdp/v1beta1/genesis.proto @@ -66,6 +66,8 @@ message Params { (gogoproto.nullable) = false ]; bool circuit_breaker = 8; + + int64 liquidation_block_interval = 9; } // DebtParam defines governance params for debt assets diff --git a/tests/e2e/kvtool b/tests/e2e/kvtool index e1085562..99214e8b 160000 --- a/tests/e2e/kvtool +++ b/tests/e2e/kvtool @@ -1 +1 @@ -Subproject commit e1085562d203fd81c5dd8576170b29715b2de9ef +Subproject commit 99214e8b5196b9ab16fa9902f956858c178921a5 diff --git a/x/cdp/abci.go b/x/cdp/abci.go index 6a66a482..694c7f0b 100644 --- a/x/cdp/abci.go +++ b/x/cdp/abci.go @@ -2,6 +2,7 @@ package cdp import ( "errors" + "fmt" "time" "github.com/cosmos/cosmos-sdk/telemetry" @@ -20,6 +21,9 @@ func BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock, k keeper.Keeper) params := k.GetParams(ctx) + // only run CDP liquidations every `LiquidationBlockInterval` blocks + skipSyncronizeAndLiquidations := ctx.BlockHeight()%params.LiquidationBlockInterval != 0 + for _, cp := range params.CollateralParams { ok := k.UpdatePricefeedStatus(ctx, cp.SpotMarketID) if !ok { @@ -36,6 +40,13 @@ func BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock, k keeper.Keeper) panic(err) } + if skipSyncronizeAndLiquidations { + ctx.Logger().Debug(fmt.Sprintf("skipping x/cdp SynchronizeInterestForRiskyCDPs and LiquidateCdps for %s", cp.Type)) + return + } + + ctx.Logger().Debug(fmt.Sprintf("running x/cdp SynchronizeInterestForRiskyCDPs and LiquidateCdps for %s", cp.Type)) + err = k.SynchronizeInterestForRiskyCDPs(ctx, cp.CheckCollateralizationIndexCount, sdk.MaxSortableDec, cp.Type) if err != nil { panic(err) diff --git a/x/cdp/abci_test.go b/x/cdp/abci_test.go index aa9275ae..564f9a84 100644 --- a/x/cdp/abci_test.go +++ b/x/cdp/abci_test.go @@ -79,10 +79,13 @@ func (suite *ModuleTestSuite) createCdps() { 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 @@ -122,37 +125,81 @@ func (suite *ModuleTestSuite) setPrice(price sdk.Dec, market string) { } 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() @@ -174,6 +221,73 @@ func (suite *ModuleTestSuite) TestSeizeSingleCdpWithFees() { 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)) } diff --git a/x/cdp/genesis_test.go b/x/cdp/genesis_test.go index 10ef9498..3b43f2f3 100644 --- a/x/cdp/genesis_test.go +++ b/x/cdp/genesis_test.go @@ -205,11 +205,12 @@ func (suite *GenesisTestSuite) Test_InitExportGenesis() { cdpGenesis := types.GenesisState{ Params: types.Params{ - GlobalDebtLimit: sdk.NewInt64Coin("usdx", 1000000000000), - SurplusAuctionThreshold: types.DefaultSurplusThreshold, - SurplusAuctionLot: types.DefaultSurplusLot, - DebtAuctionThreshold: types.DefaultDebtThreshold, - DebtAuctionLot: types.DefaultDebtLot, + 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", diff --git a/x/cdp/integration_test.go b/x/cdp/integration_test.go index 3a7f24d9..8cc8f050 100644 --- a/x/cdp/integration_test.go +++ b/x/cdp/integration_test.go @@ -113,11 +113,12 @@ func NewPricefeedGenStateMulti(cdc codec.JSONCodec) app.GenesisState { func NewCDPGenStateMulti(cdc codec.JSONCodec) app.GenesisState { cdpGenesis := types.GenesisState{ Params: types.Params{ - GlobalDebtLimit: sdk.NewInt64Coin("usdx", 1000000000000), - SurplusAuctionThreshold: types.DefaultSurplusThreshold, - SurplusAuctionLot: types.DefaultSurplusLot, - DebtAuctionThreshold: types.DefaultDebtThreshold, - DebtAuctionLot: types.DefaultDebtLot, + 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", diff --git a/x/cdp/keeper/integration_test.go b/x/cdp/keeper/integration_test.go index a7c8b8c9..bff8b1f1 100644 --- a/x/cdp/keeper/integration_test.go +++ b/x/cdp/keeper/integration_test.go @@ -42,11 +42,12 @@ func NewPricefeedGenState(cdc codec.JSONCodec, asset string, price sdk.Dec) app. func NewCDPGenState(cdc codec.JSONCodec, asset string, liquidationRatio sdk.Dec) app.GenesisState { cdpGenesis := types.GenesisState{ Params: types.Params{ - GlobalDebtLimit: sdk.NewInt64Coin("usdx", 1000000000000), - SurplusAuctionThreshold: types.DefaultSurplusThreshold, - SurplusAuctionLot: types.DefaultSurplusLot, - DebtAuctionThreshold: types.DefaultDebtThreshold, - DebtAuctionLot: types.DefaultDebtLot, + GlobalDebtLimit: sdk.NewInt64Coin("usdx", 1000000000000), + SurplusAuctionThreshold: types.DefaultSurplusThreshold, + SurplusAuctionLot: types.DefaultSurplusLot, + DebtAuctionThreshold: types.DefaultDebtThreshold, + DebtAuctionLot: types.DefaultDebtLot, + LiquidationBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, CollateralParams: types.CollateralParams{ { Denom: asset, @@ -155,11 +156,12 @@ func NewPricefeedGenStateMulti(cdc codec.JSONCodec) app.GenesisState { func NewCDPGenStateMulti(cdc codec.JSONCodec) app.GenesisState { cdpGenesis := types.GenesisState{ Params: types.Params{ - GlobalDebtLimit: sdk.NewInt64Coin("usdx", 2000000000000), - SurplusAuctionThreshold: types.DefaultSurplusThreshold, - SurplusAuctionLot: types.DefaultSurplusLot, - DebtAuctionThreshold: types.DefaultDebtThreshold, - DebtAuctionLot: types.DefaultDebtLot, + GlobalDebtLimit: sdk.NewInt64Coin("usdx", 2000000000000), + SurplusAuctionThreshold: types.DefaultSurplusThreshold, + SurplusAuctionLot: types.DefaultSurplusLot, + DebtAuctionThreshold: types.DefaultDebtThreshold, + DebtAuctionLot: types.DefaultDebtLot, + LiquidationBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, CollateralParams: types.CollateralParams{ { Denom: "xrp", @@ -248,11 +250,12 @@ func NewCDPGenStateMulti(cdc codec.JSONCodec) app.GenesisState { func NewCDPGenStateHighDebtLimit(cdc codec.JSONCodec) app.GenesisState { cdpGenesis := types.GenesisState{ Params: types.Params{ - GlobalDebtLimit: sdk.NewInt64Coin("usdx", 100000000000000), - SurplusAuctionThreshold: types.DefaultSurplusThreshold, - SurplusAuctionLot: types.DefaultSurplusLot, - DebtAuctionThreshold: types.DefaultDebtThreshold, - DebtAuctionLot: types.DefaultDebtLot, + GlobalDebtLimit: sdk.NewInt64Coin("usdx", 100000000000000), + SurplusAuctionThreshold: types.DefaultSurplusThreshold, + SurplusAuctionLot: types.DefaultSurplusLot, + DebtAuctionThreshold: types.DefaultDebtThreshold, + DebtAuctionLot: types.DefaultDebtLot, + LiquidationBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, CollateralParams: types.CollateralParams{ { Denom: "xrp", diff --git a/x/cdp/keeper/migrations.go b/x/cdp/keeper/migrations.go new file mode 100644 index 00000000..7b8a0c18 --- /dev/null +++ b/x/cdp/keeper/migrations.go @@ -0,0 +1,23 @@ +package keeper + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + v2 "github.com/kava-labs/kava/x/cdp/migrations/v2" +) + +// Migrator is a struct for handling in-place store migrations. +type Migrator struct { + keeper Keeper +} + +// NewMigrator returns a new Migrator. +func NewMigrator(keeper Keeper) Migrator { + return Migrator{ + keeper: keeper, + } +} + +// Migrate1to2 migrates from version 1 to 2. +func (m Migrator) Migrate1to2(ctx sdk.Context) error { + return v2.MigrateStore(ctx, m.keeper.paramSubspace) +} diff --git a/x/cdp/keeper/params.go b/x/cdp/keeper/params.go index 681ace35..62b3a4a6 100644 --- a/x/cdp/keeper/params.go +++ b/x/cdp/keeper/params.go @@ -12,7 +12,7 @@ import ( // GetParams returns the params from the store func (k Keeper) GetParams(ctx sdk.Context) types.Params { var p types.Params - k.paramSubspace.GetParamSet(ctx, &p) + k.paramSubspace.GetParamSetIfExists(ctx, &p) return p } diff --git a/x/cdp/legacy/v0_15/types.go b/x/cdp/legacy/v0_15/types.go deleted file mode 100644 index dde3b41b..00000000 --- a/x/cdp/legacy/v0_15/types.go +++ /dev/null @@ -1,109 +0,0 @@ -package v0_15 - -import ( - "time" - - sdkmath "cosmossdk.io/math" - sdk "github.com/cosmos/cosmos-sdk/types" -) - -const ( - // ModuleName The name that will be used throughout the module - ModuleName = "cdp" -) - -// GenesisState is the state that must be provided at genesis. -type GenesisState struct { - Params Params `json:"params" yaml:"params"` - CDPs CDPs `json:"cdps" yaml:"cdps"` - Deposits Deposits `json:"deposits" yaml:"deposits"` - StartingCdpID uint64 `json:"starting_cdp_id" yaml:"starting_cdp_id"` - DebtDenom string `json:"debt_denom" yaml:"debt_denom"` - GovDenom string `json:"gov_denom" yaml:"gov_denom"` - PreviousAccumulationTimes GenesisAccumulationTimes `json:"previous_accumulation_times" yaml:"previous_accumulation_times"` - TotalPrincipals GenesisTotalPrincipals `json:"total_principals" yaml:"total_principals"` -} - -// Params governance parameters for cdp module -type Params struct { - CollateralParams CollateralParams `json:"collateral_params" yaml:"collateral_params"` - DebtParam DebtParam `json:"debt_param" yaml:"debt_param"` - GlobalDebtLimit sdk.Coin `json:"global_debt_limit" yaml:"global_debt_limit"` - SurplusAuctionThreshold sdkmath.Int `json:"surplus_auction_threshold" yaml:"surplus_auction_threshold"` - SurplusAuctionLot sdkmath.Int `json:"surplus_auction_lot" yaml:"surplus_auction_lot"` - DebtAuctionThreshold sdkmath.Int `json:"debt_auction_threshold" yaml:"debt_auction_threshold"` - DebtAuctionLot sdkmath.Int `json:"debt_auction_lot" yaml:"debt_auction_lot"` - CircuitBreaker bool `json:"circuit_breaker" yaml:"circuit_breaker"` -} - -// CollateralParams array of CollateralParam -type CollateralParams []CollateralParam - -// CollateralParam governance parameters for each collateral type within the cdp module -type CollateralParam struct { - Denom string `json:"denom" yaml:"denom"` // Coin name of collateral type - Type string `json:"type" yaml:"type"` - LiquidationRatio sdk.Dec `json:"liquidation_ratio" yaml:"liquidation_ratio"` // The ratio (Collateral (priced in stable coin) / Debt) under which a CDP will be liquidated - DebtLimit sdk.Coin `json:"debt_limit" yaml:"debt_limit"` // Maximum amount of debt allowed to be drawn from this collateral type - StabilityFee sdk.Dec `json:"stability_fee" yaml:"stability_fee"` // per second stability fee for loans opened using this collateral - AuctionSize sdkmath.Int `json:"auction_size" yaml:"auction_size"` // Max amount of collateral to sell off in any one auction. - LiquidationPenalty sdk.Dec `json:"liquidation_penalty" yaml:"liquidation_penalty"` // percentage penalty (between [0, 1]) applied to a cdp if it is liquidated - Prefix byte `json:"prefix" yaml:"prefix"` - SpotMarketID string `json:"spot_market_id" yaml:"spot_market_id"` // marketID of the spot price of the asset from the pricefeed - used for opening CDPs, depositing, withdrawing - LiquidationMarketID string `json:"liquidation_market_id" yaml:"liquidation_market_id"` // marketID of the pricefeed used for liquidation - KeeperRewardPercentage sdk.Dec `json:"keeper_reward_percentage" yaml:"keeper_reward_percentage"` // the percentage of a CDPs collateral that gets rewarded to a keeper that liquidates the position - CheckCollateralizationIndexCount sdkmath.Int `json:"check_collateralization_index_count" yaml:"check_collateralization_index_count"` // the number of cdps that will be checked for liquidation in the begin blocker - ConversionFactor sdkmath.Int `json:"conversion_factor" yaml:"conversion_factor"` // factor for converting internal units to one base unit of collateral -} - -// CDPs a collection of CDP objects -type CDPs []CDP - -// CDP is the state of a single collateralized debt position. -type CDP struct { - ID uint64 `json:"id" yaml:"id"` // unique id for cdp - Owner sdk.AccAddress `json:"owner" yaml:"owner"` // Account that authorizes changes to the CDP - Type string `json:"type" yaml:"type"` // string representing the unique collateral type of the CDP - Collateral sdk.Coin `json:"collateral" yaml:"collateral"` // Amount of collateral stored in this CDP - Principal sdk.Coin `json:"principal" yaml:"principal"` // Amount of debt drawn using the CDP - AccumulatedFees sdk.Coin `json:"accumulated_fees" yaml:"accumulated_fees"` // Fees accumulated since the CDP was opened or debt was last repaid - FeesUpdated time.Time `json:"fees_updated" yaml:"fees_updated"` // The time when fees were last updated - InterestFactor sdk.Dec `json:"interest_factor" yaml:"interest_factor"` // the interest factor when fees were last calculated for this CDP -} - -// Deposits a collection of Deposit objects -type Deposits []Deposit - -// Deposit defines an amount of coins deposited by an account to a cdp -type Deposit struct { - CdpID uint64 `json:"cdp_id" yaml:"cdp_id"` // cdpID of the cdp - Depositor sdk.AccAddress `json:"depositor" yaml:"depositor"` // Address of the depositor - Amount sdk.Coin `json:"amount" yaml:"amount"` // Deposit amount -} - -// GenesisAccumulationTimes slice of GenesisAccumulationTime -type GenesisAccumulationTimes []GenesisAccumulationTime - -// GenesisAccumulationTime stores the previous distribution time and its corresponding denom -type GenesisAccumulationTime struct { - CollateralType string `json:"collateral_type" yaml:"collateral_type"` - PreviousAccumulationTime time.Time `json:"previous_accumulation_time" yaml:"previous_accumulation_time"` - InterestFactor sdk.Dec `json:"interest_factor" yaml:"interest_factor"` -} - -// GenesisTotalPrincipals slice of GenesisTotalPrincipal -type GenesisTotalPrincipals []GenesisTotalPrincipal - -// GenesisTotalPrincipal stores the total principal and its corresponding collateral type -type GenesisTotalPrincipal struct { - CollateralType string `json:"collateral_type" yaml:"collateral_type"` - TotalPrincipal sdkmath.Int `json:"total_principal" yaml:"total_principal"` -} - -// DebtParam governance params for debt assets -type DebtParam struct { - Denom string `json:"denom" yaml:"denom"` - ReferenceAsset string `json:"reference_asset" yaml:"reference_asset"` - ConversionFactor sdkmath.Int `json:"conversion_factor" yaml:"conversion_factor"` - DebtFloor sdkmath.Int `json:"debt_floor" yaml:"debt_floor"` // minimum active loan size, used to prevent dust -} diff --git a/x/cdp/legacy/v0_16/migrate.go b/x/cdp/legacy/v0_16/migrate.go deleted file mode 100644 index 9a16fec8..00000000 --- a/x/cdp/legacy/v0_16/migrate.go +++ /dev/null @@ -1,109 +0,0 @@ -package v0_16 - -import ( - v015cdp "github.com/kava-labs/kava/x/cdp/legacy/v0_15" - v016cdp "github.com/kava-labs/kava/x/cdp/types" -) - -func migrateParams(params v015cdp.Params) v016cdp.Params { - // migrate collateral params - collateralParams := make(v016cdp.CollateralParams, len(params.CollateralParams)) - for i, cp := range params.CollateralParams { - collateralParams[i] = v016cdp.CollateralParam{ - Denom: cp.Denom, - Type: cp.Type, - LiquidationRatio: cp.LiquidationRatio, - DebtLimit: cp.DebtLimit, - StabilityFee: cp.StabilityFee, - AuctionSize: cp.AuctionSize, - LiquidationPenalty: cp.LiquidationPenalty, - SpotMarketID: cp.SpotMarketID, - LiquidationMarketID: cp.LiquidationMarketID, - KeeperRewardPercentage: cp.KeeperRewardPercentage, - CheckCollateralizationIndexCount: cp.CheckCollateralizationIndexCount, - ConversionFactor: cp.ConversionFactor, - } - } - - return v016cdp.Params{ - CollateralParams: collateralParams, - DebtParam: v016cdp.DebtParam{ - Denom: params.DebtParam.Denom, - ReferenceAsset: params.DebtParam.ReferenceAsset, - ConversionFactor: params.DebtParam.ConversionFactor, - DebtFloor: params.DebtParam.DebtFloor, - }, - GlobalDebtLimit: params.GlobalDebtLimit, - SurplusAuctionThreshold: params.SurplusAuctionThreshold, - SurplusAuctionLot: params.SurplusAuctionLot, - DebtAuctionThreshold: params.DebtAuctionThreshold, - DebtAuctionLot: params.DebtAuctionLot, - CircuitBreaker: params.CircuitBreaker, - } -} - -func migrateCDPs(oldCDPs v015cdp.CDPs) v016cdp.CDPs { - cdps := make(v016cdp.CDPs, len(oldCDPs)) - for i, cdp := range oldCDPs { - cdps[i] = v016cdp.CDP{ - ID: cdp.ID, - Owner: cdp.Owner, - Type: cdp.Type, - Collateral: cdp.Collateral, - Principal: cdp.Principal, - AccumulatedFees: cdp.AccumulatedFees, - FeesUpdated: cdp.FeesUpdated, - InterestFactor: cdp.InterestFactor, - } - } - return cdps -} - -func migrateDeposits(oldDeposits v015cdp.Deposits) v016cdp.Deposits { - deposits := make(v016cdp.Deposits, len(oldDeposits)) - for i, deposit := range oldDeposits { - deposits[i] = v016cdp.Deposit{ - CdpID: deposit.CdpID, - Depositor: deposit.Depositor, - Amount: deposit.Amount, - } - } - return deposits -} - -func migratePrevAccTimes(oldPrevAccTimes v015cdp.GenesisAccumulationTimes) v016cdp.GenesisAccumulationTimes { - prevAccTimes := make(v016cdp.GenesisAccumulationTimes, len(oldPrevAccTimes)) - for i, prevAccTime := range oldPrevAccTimes { - prevAccTimes[i] = v016cdp.GenesisAccumulationTime{ - CollateralType: prevAccTime.CollateralType, - PreviousAccumulationTime: prevAccTime.PreviousAccumulationTime, - InterestFactor: prevAccTime.InterestFactor, - } - } - return prevAccTimes -} - -func migrateTotalPrincipals(oldTotalPrincipals v015cdp.GenesisTotalPrincipals) v016cdp.GenesisTotalPrincipals { - totalPrincipals := make(v016cdp.GenesisTotalPrincipals, len(oldTotalPrincipals)) - for i, tp := range oldTotalPrincipals { - totalPrincipals[i] = v016cdp.GenesisTotalPrincipal{ - CollateralType: tp.CollateralType, - TotalPrincipal: tp.TotalPrincipal, - } - } - return totalPrincipals -} - -// Migrate converts v0.15 cdp state and returns it in v0.16 format -func Migrate(oldState v015cdp.GenesisState) *v016cdp.GenesisState { - return &v016cdp.GenesisState{ - Params: migrateParams(oldState.Params), - CDPs: migrateCDPs(oldState.CDPs), - Deposits: migrateDeposits(oldState.Deposits), - StartingCdpID: oldState.StartingCdpID, - DebtDenom: oldState.DebtDenom, - GovDenom: oldState.GovDenom, - PreviousAccumulationTimes: migratePrevAccTimes(oldState.PreviousAccumulationTimes), - TotalPrincipals: migrateTotalPrincipals(oldState.TotalPrincipals), - } -} diff --git a/x/cdp/legacy/v0_16/migrate_test.go b/x/cdp/legacy/v0_16/migrate_test.go deleted file mode 100644 index 58669e32..00000000 --- a/x/cdp/legacy/v0_16/migrate_test.go +++ /dev/null @@ -1,216 +0,0 @@ -package v0_16 - -import ( - "io/ioutil" - "path/filepath" - "testing" - "time" - - sdkmath "cosmossdk.io/math" - "github.com/cosmos/cosmos-sdk/codec" - sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/stretchr/testify/suite" - - app "github.com/kava-labs/kava/app" - v015cdp "github.com/kava-labs/kava/x/cdp/legacy/v0_15" - v016cdp "github.com/kava-labs/kava/x/cdp/types" -) - -type migrateTestSuite struct { - suite.Suite - - addresses []sdk.AccAddress - v15genstate v015cdp.GenesisState - cdc codec.Codec - legacyCdc *codec.LegacyAmino -} - -func (s *migrateTestSuite) SetupTest() { - app.SetSDKConfig() - - s.v15genstate = v015cdp.GenesisState{ - Params: v015cdp.Params{}, - CDPs: v015cdp.CDPs{}, - Deposits: v015cdp.Deposits{}, - StartingCdpID: 1, - DebtDenom: "usdx", - GovDenom: "ukava", - PreviousAccumulationTimes: v015cdp.GenesisAccumulationTimes{}, - TotalPrincipals: v015cdp.GenesisTotalPrincipals{}, - } - - config := app.MakeEncodingConfig() - s.cdc = config.Marshaler - - legacyCodec := codec.NewLegacyAmino() - s.legacyCdc = legacyCodec - - _, accAddresses := app.GeneratePrivKeyAddressPairs(10) - s.addresses = accAddresses -} - -func (s *migrateTestSuite) TestMigrate_JSON() { - file := filepath.Join("testdata", "v15-cdp.json") - data, err := ioutil.ReadFile(file) - s.Require().NoError(err) - err = s.legacyCdc.UnmarshalJSON(data, &s.v15genstate) - s.Require().NoError(err) - genstate := Migrate(s.v15genstate) - actual := s.cdc.MustMarshalJSON(genstate) - - file = filepath.Join("testdata", "v16-cdp.json") - expected, err := ioutil.ReadFile(file) - s.Require().NoError(err) - s.Require().JSONEq(string(expected), string(actual)) -} - -func (s *migrateTestSuite) TestMigrate_GenState() { - s.v15genstate = v015cdp.GenesisState{ - StartingCdpID: 2, - DebtDenom: "usdx", - GovDenom: "ukava", - Params: v015cdp.Params{ - CollateralParams: v015cdp.CollateralParams{ - { - Denom: "xrp", - Type: "xrp-a", - LiquidationRatio: sdk.MustNewDecFromStr("2.0"), - DebtLimit: sdk.NewInt64Coin("usdx", 500000000000), - StabilityFee: sdk.MustNewDecFromStr("1.012"), - LiquidationPenalty: sdk.MustNewDecFromStr("0.05"), - AuctionSize: sdkmath.NewInt(70), - SpotMarketID: "xrp:usd", - LiquidationMarketID: "xrp:usd", - KeeperRewardPercentage: sdk.MustNewDecFromStr("0.01"), - CheckCollateralizationIndexCount: sdkmath.NewInt(10), - ConversionFactor: sdkmath.NewInt(6), - }, - }, - DebtParam: v015cdp.DebtParam{ - Denom: "usdx", - ReferenceAsset: "usd", - ConversionFactor: sdkmath.NewInt(6), - DebtFloor: sdkmath.NewInt(100), - }, - GlobalDebtLimit: sdk.NewInt64Coin("usdx", 1000000000000), - SurplusAuctionThreshold: sdkmath.NewInt(6), - SurplusAuctionLot: sdkmath.NewInt(7), - DebtAuctionThreshold: sdkmath.NewInt(8), - DebtAuctionLot: sdkmath.NewInt(9), - }, - CDPs: v015cdp.CDPs{ - { - ID: 2, - Owner: s.addresses[0], - Type: "xrp-a", - Collateral: sdk.NewCoin("xrp", sdkmath.NewInt(2123)), - Principal: sdk.NewCoin("usdx", sdkmath.NewInt(100)), - AccumulatedFees: sdk.NewCoin("usdx", sdk.ZeroInt()), - FeesUpdated: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), - InterestFactor: sdk.NewDec(1), - }, - }, - Deposits: v015cdp.Deposits{ - { - CdpID: 1, - Depositor: s.addresses[0], - Amount: sdk.NewCoin("usdx", sdkmath.NewInt(100)), - }, - { - CdpID: 2, - Depositor: s.addresses[1], - Amount: sdk.NewCoin("ukava", sdkmath.NewInt(1200)), - }, - }, - PreviousAccumulationTimes: v015cdp.GenesisAccumulationTimes{ - { - CollateralType: "usdx", - PreviousAccumulationTime: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), - InterestFactor: sdk.MustNewDecFromStr("0.02"), - }, - }, - TotalPrincipals: v015cdp.GenesisTotalPrincipals{ - { - CollateralType: "usdx", - TotalPrincipal: sdkmath.NewInt(1200), - }, - }, - } - expected := v016cdp.GenesisState{ - StartingCdpID: 2, - DebtDenom: "usdx", - GovDenom: "ukava", - Params: v016cdp.Params{ - CollateralParams: v016cdp.CollateralParams{ - { - Denom: "xrp", - Type: "xrp-a", - LiquidationRatio: sdk.MustNewDecFromStr("2.0"), - DebtLimit: sdk.NewInt64Coin("usdx", 500000000000), - StabilityFee: sdk.MustNewDecFromStr("1.012"), - LiquidationPenalty: sdk.MustNewDecFromStr("0.05"), - AuctionSize: sdkmath.NewInt(70), - SpotMarketID: "xrp:usd", - LiquidationMarketID: "xrp:usd", - KeeperRewardPercentage: sdk.MustNewDecFromStr("0.01"), - CheckCollateralizationIndexCount: sdkmath.NewInt(10), - ConversionFactor: sdkmath.NewInt(6), - }, - }, - DebtParam: v016cdp.DebtParam{ - Denom: "usdx", - ReferenceAsset: "usd", - ConversionFactor: sdkmath.NewInt(6), - DebtFloor: sdkmath.NewInt(100), - }, - GlobalDebtLimit: sdk.NewInt64Coin("usdx", 1000000000000), - SurplusAuctionThreshold: sdkmath.NewInt(6), - SurplusAuctionLot: sdkmath.NewInt(7), - DebtAuctionThreshold: sdkmath.NewInt(8), - DebtAuctionLot: sdkmath.NewInt(9), - }, - CDPs: v016cdp.CDPs{ - { - ID: 2, - Owner: s.addresses[0], - Type: "xrp-a", - Collateral: sdk.NewCoin("xrp", sdkmath.NewInt(2123)), - Principal: sdk.NewCoin("usdx", sdkmath.NewInt(100)), - AccumulatedFees: sdk.NewCoin("usdx", sdk.ZeroInt()), - FeesUpdated: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), - InterestFactor: sdk.NewDec(1), - }, - }, - Deposits: v016cdp.Deposits{ - { - CdpID: 1, - Depositor: s.addresses[0], - Amount: sdk.NewCoin("usdx", sdkmath.NewInt(100)), - }, - { - CdpID: 2, - Depositor: s.addresses[1], - Amount: sdk.NewCoin("ukava", sdkmath.NewInt(1200)), - }, - }, - PreviousAccumulationTimes: v016cdp.GenesisAccumulationTimes{ - { - CollateralType: "usdx", - PreviousAccumulationTime: time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC), - InterestFactor: sdk.MustNewDecFromStr("0.02"), - }, - }, - TotalPrincipals: v016cdp.GenesisTotalPrincipals{ - { - CollateralType: "usdx", - TotalPrincipal: sdkmath.NewInt(1200), - }, - }, - } - genState := Migrate(s.v15genstate) - s.Require().Equal(expected, *genState) -} - -func TestCdpMigrateTestSuite(t *testing.T) { - suite.Run(t, new(migrateTestSuite)) -} diff --git a/x/cdp/legacy/v0_16/testdata/v15-cdp.json b/x/cdp/legacy/v0_16/testdata/v15-cdp.json deleted file mode 100644 index 8fc5dfac..00000000 --- a/x/cdp/legacy/v0_16/testdata/v15-cdp.json +++ /dev/null @@ -1,135 +0,0 @@ -{ - "cdps": [ - { - "accumulated_fees": { - "amount": "36088", - "denom": "usdx" - }, - "collateral": { - "amount": "40911876", - "denom": "bnb" - }, - "fees_updated": "2021-11-05T21:13:12.85608847Z", - "id": "19", - "interest_factor": "1.002881426571765716", - "owner": "kava1u4p6a2yse66ewfndw4j7ppsa777vdcex3m4n9s", - "principal": { - "amount": "10016831", - "denom": "usdx" - }, - "type": "bnb-a" - }, - { - "accumulated_fees": { - "amount": "156662", - "denom": "usdx" - }, - "collateral": { - "amount": "88268546", - "denom": "bnb" - }, - "fees_updated": "2021-11-05T21:13:12.85608847Z", - "id": "22", - "interest_factor": "1.002881426571765716", - "owner": "kava1e8xjfylam4nvugcmkxwvuxh22uvvad5vknu4yh", - "principal": { - "amount": "10000000", - "denom": "usdx" - }, - "type": "bnb-a" - } - ], - "debt_denom": "debt", - "deposits": [ - { - "amount": { - "amount": "40911876", - "denom": "bnb" - }, - "cdp_id": "19", - "depositor": "kava1u4p6a2yse66ewfndw4j7ppsa777vdcex3m4n9s" - }, - { - "amount": { - "amount": "88268546", - "denom": "bnb" - }, - "cdp_id": "22", - "depositor": "kava1e8xjfylam4nvugcmkxwvuxh22uvvad5vknu4yh" - } - ], - "gov_denom": "ukava", - "params": { - "circuit_breaker": false, - "collateral_params": [ - { - "auction_size": "50000000000", - "conversion_factor": "8", - "debt_limit": { - "amount": "20000000000000", - "denom": "usdx" - }, - "denom": "bnb", - "liquidation_market_id": "bnb:usd:30", - "liquidation_penalty": "0.050000000000000000", - "liquidation_ratio": "1.500000000000000000", - "keeper_reward_percentage": "0.01", - "check_collateralization_index_count": "10", - "prefix": 1, - "spot_market_id": "bnb:usd", - "stability_fee": "1.000000000782997700", - "type": "bnb-a" - }, - { - "denom": "hbtc", - "type": "hbtc-a", - "liquidation_ratio": "1.500000000000000000", - "debt_limit": { - "denom": "usdx", - "amount": "10000000000000" - }, - "stability_fee": "1.000000001547125958", - "auction_size": "1000000000000", - "liquidation_penalty": "0.075000000000000000", - "check_collateralization_index_count": "10", - "keeper_reward_percentage": "0.01", - "prefix": 8, - "spot_market_id": "btc:usd", - "liquidation_market_id": "btc:usd:30", - "conversion_factor": "8" - } - ], - "debt_auction_lot": "10000000000", - "debt_auction_threshold": "100000000000", - "debt_param": { - "conversion_factor": "6", - "debt_floor": "10000000", - "denom": "usdx", - "reference_asset": "usd", - "savings_rate": "0.950000000000000000" - }, - "global_debt_limit": { - "amount": "43000000000000", - "denom": "usdx" - }, - "savings_distribution_frequency": "43200000000000", - "surplus_auction_lot": "10000000000", - "surplus_auction_threshold": "500000000000" - }, - "previous_distribution_time": "1970-01-01T00:00:00Z", - "savings_rate_distributed": "0", - "starting_cdp_id": "1", - "previous_accumulation_times": [ - { - "collateral_type": "bnb-a", - "interest_factor": "1.002881426571765716", - "previous_accumulation_time": "2021-11-05T21:13:12.85608847Z" - } - ], - "total_principals": [ - { - "collateral_type": "bnb-a", - "total_principal": "9285009581820" - } - ] -} diff --git a/x/cdp/legacy/v0_16/testdata/v16-cdp.json b/x/cdp/legacy/v0_16/testdata/v16-cdp.json deleted file mode 100644 index 160ca144..00000000 --- a/x/cdp/legacy/v0_16/testdata/v16-cdp.json +++ /dev/null @@ -1,93 +0,0 @@ -{ - "params": { - "collateral_params": [ - { - "denom": "bnb", - "type": "bnb-a", - "liquidation_ratio": "1.500000000000000000", - "debt_limit": { "denom": "usdx", "amount": "20000000000000" }, - "stability_fee": "1.000000000782997700", - "auction_size": "50000000000", - "liquidation_penalty": "0.050000000000000000", - "spot_market_id": "bnb:usd", - "liquidation_market_id": "bnb:usd:30", - "keeper_reward_percentage": "0.010000000000000000", - "check_collateralization_index_count": "10", - "conversion_factor": "8" - }, - { - "denom": "hbtc", - "type": "hbtc-a", - "liquidation_ratio": "1.500000000000000000", - "debt_limit": { "denom": "usdx", "amount": "10000000000000" }, - "stability_fee": "1.000000001547125958", - "auction_size": "1000000000000", - "liquidation_penalty": "0.075000000000000000", - "spot_market_id": "btc:usd", - "liquidation_market_id": "btc:usd:30", - "keeper_reward_percentage": "0.010000000000000000", - "check_collateralization_index_count": "10", - "conversion_factor": "8" - } - ], - "debt_param": { - "denom": "usdx", - "reference_asset": "usd", - "conversion_factor": "6", - "debt_floor": "10000000" - }, - "global_debt_limit": { "denom": "usdx", "amount": "43000000000000" }, - "surplus_auction_threshold": "500000000000", - "surplus_auction_lot": "10000000000", - "debt_auction_threshold": "100000000000", - "debt_auction_lot": "10000000000", - "circuit_breaker": false - }, - "cdps": [ - { - "id": "19", - "owner": "kava1u4p6a2yse66ewfndw4j7ppsa777vdcex3m4n9s", - "type": "bnb-a", - "collateral": { "denom": "bnb", "amount": "40911876" }, - "principal": { "denom": "usdx", "amount": "10016831" }, - "accumulated_fees": { "denom": "usdx", "amount": "36088" }, - "fees_updated": "2021-11-05T21:13:12.856088470Z", - "interest_factor": "1.002881426571765716" - }, - { - "id": "22", - "owner": "kava1e8xjfylam4nvugcmkxwvuxh22uvvad5vknu4yh", - "type": "bnb-a", - "collateral": { "denom": "bnb", "amount": "88268546" }, - "principal": { "denom": "usdx", "amount": "10000000" }, - "accumulated_fees": { "denom": "usdx", "amount": "156662" }, - "fees_updated": "2021-11-05T21:13:12.856088470Z", - "interest_factor": "1.002881426571765716" - } - ], - "deposits": [ - { - "cdp_id": "19", - "depositor": "kava1u4p6a2yse66ewfndw4j7ppsa777vdcex3m4n9s", - "amount": { "denom": "bnb", "amount": "40911876" } - }, - { - "cdp_id": "22", - "depositor": "kava1e8xjfylam4nvugcmkxwvuxh22uvvad5vknu4yh", - "amount": { "denom": "bnb", "amount": "88268546" } - } - ], - "starting_cdp_id": "1", - "debt_denom": "debt", - "gov_denom": "ukava", - "previous_accumulation_times": [ - { - "collateral_type": "bnb-a", - "previous_accumulation_time": "2021-11-05T21:13:12.856088470Z", - "interest_factor": "1.002881426571765716" - } - ], - "total_principals": [ - { "collateral_type": "bnb-a", "total_principal": "9285009581820" } - ] -} diff --git a/x/cdp/migrations/v2/store.go b/x/cdp/migrations/v2/store.go new file mode 100644 index 00000000..f457c174 --- /dev/null +++ b/x/cdp/migrations/v2/store.go @@ -0,0 +1,22 @@ +package v2 + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" + "github.com/kava-labs/kava/x/cdp/types" +) + +// MigrateStore performs in-place store migrations for consensus version 2 +// V2 adds the begin_blocker_execution_block_interval param to parameters. +func MigrateStore(ctx sdk.Context, paramstore paramtypes.Subspace) error { + migrateParamsStore(ctx, paramstore) + return nil +} + +// migrateParamsStore ensures the param key table exists and has the begin_blocker_execution_block_interval property +func migrateParamsStore(ctx sdk.Context, paramstore paramtypes.Subspace) { + if !paramstore.HasKeyTable() { + paramstore.WithKeyTable(types.ParamKeyTable()) + } + paramstore.Set(ctx, types.KeyBeginBlockerExecutionBlockInterval, types.DefaultBeginBlockerExecutionBlockInterval) +} diff --git a/x/cdp/migrations/v2/store_test.go b/x/cdp/migrations/v2/store_test.go new file mode 100644 index 00000000..9a585967 --- /dev/null +++ b/x/cdp/migrations/v2/store_test.go @@ -0,0 +1,63 @@ +package v2_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/cosmos/cosmos-sdk/simapp" + "github.com/cosmos/cosmos-sdk/testutil" + sdk "github.com/cosmos/cosmos-sdk/types" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" + + v2cdp "github.com/kava-labs/kava/x/cdp/migrations/v2" + "github.com/kava-labs/kava/x/cdp/types" +) + +func TestStoreMigrationAddsKeyTableIncludingNewParam(t *testing.T) { + encCfg := simapp.MakeTestEncodingConfig() + cdpKey := sdk.NewKVStoreKey(types.ModuleName) + tcdpKey := sdk.NewTransientStoreKey("transient_test") + ctx := testutil.DefaultContext(cdpKey, tcdpKey) + paramstore := paramtypes.NewSubspace(encCfg.Codec, encCfg.Amino, cdpKey, tcdpKey, types.ModuleName) + + // Check param doesn't exist before + require.False(t, paramstore.Has(ctx, types.KeyBeginBlockerExecutionBlockInterval)) + + // Run migrations. + err := v2cdp.MigrateStore(ctx, paramstore) + require.NoError(t, err) + + // Make sure the new params are set. + require.True(t, paramstore.Has(ctx, types.KeyBeginBlockerExecutionBlockInterval)) + // Assert the value is what we expect + result := types.DefaultBeginBlockerExecutionBlockInterval + paramstore.Get(ctx, types.KeyBeginBlockerExecutionBlockInterval, &result) + require.Equal(t, result, types.DefaultBeginBlockerExecutionBlockInterval) +} + +func TestStoreMigrationSetsNewParamOnExistingKeyTable(t *testing.T) { + encCfg := simapp.MakeTestEncodingConfig() + cdpKey := sdk.NewKVStoreKey(types.ModuleName) + tcdpKey := sdk.NewTransientStoreKey("transient_test") + ctx := testutil.DefaultContext(cdpKey, tcdpKey) + paramstore := paramtypes.NewSubspace(encCfg.Codec, encCfg.Amino, cdpKey, tcdpKey, types.ModuleName) + paramstore.WithKeyTable(types.ParamKeyTable()) + + // expect it to have key table + require.True(t, paramstore.HasKeyTable()) + // expect it to not have new param + require.False(t, paramstore.Has(ctx, types.KeyBeginBlockerExecutionBlockInterval)) + + // Run migrations. + err := v2cdp.MigrateStore(ctx, paramstore) + require.NoError(t, err) + + // Make sure the new params are set. + require.True(t, paramstore.Has(ctx, types.KeyBeginBlockerExecutionBlockInterval)) + + // Assert the value is what we expect + result := types.DefaultBeginBlockerExecutionBlockInterval + paramstore.Get(ctx, types.KeyBeginBlockerExecutionBlockInterval, &result) + require.Equal(t, result, types.DefaultBeginBlockerExecutionBlockInterval) +} diff --git a/x/cdp/module.go b/x/cdp/module.go index 599e2714..8061ea42 100644 --- a/x/cdp/module.go +++ b/x/cdp/module.go @@ -3,6 +3,7 @@ package cdp import ( "context" "encoding/json" + "fmt" "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" @@ -26,6 +27,9 @@ var ( // _ module.AppModuleSimulation = AppModule{} ) +// ConsensusVersion defines the current module consensus version. +const ConsensusVersion = 2 + // AppModuleBasic app module basics object type AppModuleBasic struct{} @@ -75,7 +79,7 @@ func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc *codec.LegacyAmino) sd // ConsensusVersion implements AppModule/ConsensusVersion. func (AppModule) ConsensusVersion() uint64 { - return 1 + return ConsensusVersion } // GetTxCmd returns the root tx command for the cdp module. @@ -133,6 +137,11 @@ func (AppModule) QuerierRoute() string { func (am AppModule) RegisterServices(cfg module.Configurator) { types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper)) types.RegisterQueryServer(cfg.QueryServer(), keeper.NewQueryServerImpl(am.keeper)) + + m := keeper.NewMigrator(am.keeper) + if err := cfg.RegisterMigration(types.ModuleName, 1, m.Migrate1to2); err != nil { + panic(fmt.Sprintf("failed to migrate x/cdp from version 1 to 2: %v", err)) + } } // InitGenesis module init-genesis diff --git a/x/cdp/types/genesis.pb.go b/x/cdp/types/genesis.pb.go index 7939ed3e..c40fc9f4 100644 --- a/x/cdp/types/genesis.pb.go +++ b/x/cdp/types/genesis.pb.go @@ -134,14 +134,15 @@ func (m *GenesisState) GetTotalPrincipals() GenesisTotalPrincipals { // Params defines the parameters for the cdp module. type Params struct { - CollateralParams CollateralParams `protobuf:"bytes,1,rep,name=collateral_params,json=collateralParams,proto3,castrepeated=CollateralParams" json:"collateral_params"` - DebtParam DebtParam `protobuf:"bytes,2,opt,name=debt_param,json=debtParam,proto3" json:"debt_param"` - GlobalDebtLimit types.Coin `protobuf:"bytes,3,opt,name=global_debt_limit,json=globalDebtLimit,proto3" json:"global_debt_limit"` - SurplusAuctionThreshold github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=surplus_auction_threshold,json=surplusAuctionThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"surplus_auction_threshold"` - SurplusAuctionLot github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=surplus_auction_lot,json=surplusAuctionLot,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"surplus_auction_lot"` - DebtAuctionThreshold github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=debt_auction_threshold,json=debtAuctionThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"debt_auction_threshold"` - DebtAuctionLot github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=debt_auction_lot,json=debtAuctionLot,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"debt_auction_lot"` - CircuitBreaker bool `protobuf:"varint,8,opt,name=circuit_breaker,json=circuitBreaker,proto3" json:"circuit_breaker,omitempty"` + CollateralParams CollateralParams `protobuf:"bytes,1,rep,name=collateral_params,json=collateralParams,proto3,castrepeated=CollateralParams" json:"collateral_params"` + DebtParam DebtParam `protobuf:"bytes,2,opt,name=debt_param,json=debtParam,proto3" json:"debt_param"` + GlobalDebtLimit types.Coin `protobuf:"bytes,3,opt,name=global_debt_limit,json=globalDebtLimit,proto3" json:"global_debt_limit"` + SurplusAuctionThreshold github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=surplus_auction_threshold,json=surplusAuctionThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"surplus_auction_threshold"` + SurplusAuctionLot github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=surplus_auction_lot,json=surplusAuctionLot,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"surplus_auction_lot"` + DebtAuctionThreshold github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=debt_auction_threshold,json=debtAuctionThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"debt_auction_threshold"` + DebtAuctionLot github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=debt_auction_lot,json=debtAuctionLot,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"debt_auction_lot"` + CircuitBreaker bool `protobuf:"varint,8,opt,name=circuit_breaker,json=circuitBreaker,proto3" json:"circuit_breaker,omitempty"` + LiquidationBlockInterval int64 `protobuf:"varint,9,opt,name=liquidation_block_interval,json=liquidationBlockInterval,proto3" json:"liquidation_block_interval,omitempty"` } func (m *Params) Reset() { *m = Params{} } @@ -205,6 +206,13 @@ func (m *Params) GetCircuitBreaker() bool { return false } +func (m *Params) GetLiquidationBlockInterval() int64 { + if m != nil { + return m.LiquidationBlockInterval + } + return 0 +} + // DebtParam defines governance params for debt assets type DebtParam struct { Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` @@ -456,81 +464,83 @@ func init() { func init() { proto.RegisterFile("kava/cdp/v1beta1/genesis.proto", fileDescriptor_e4494a90aaab0034) } var fileDescriptor_e4494a90aaab0034 = []byte{ - // 1179 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xcd, 0x6e, 0x1b, 0x37, - 0x10, 0xf6, 0x3a, 0x8a, 0x23, 0xd1, 0x8a, 0x24, 0x33, 0x4e, 0xb2, 0x76, 0x50, 0x49, 0x75, 0xd1, - 0xc6, 0x3d, 0x58, 0x42, 0x52, 0x20, 0x40, 0x81, 0xa2, 0xa9, 0x65, 0xc1, 0x81, 0x11, 0x17, 0x10, - 0xd6, 0x3e, 0xb5, 0x87, 0x05, 0x97, 0x4b, 0xc9, 0x84, 0x56, 0xcb, 0x2d, 0x49, 0xa9, 0xb6, 0x5f, - 0xa1, 0x28, 0x1a, 0xf4, 0x25, 0x0a, 0xe4, 0xdc, 0x87, 0x48, 0x6f, 0x41, 0x4f, 0x45, 0x0f, 0x72, - 0x21, 0xdf, 0xfb, 0x0c, 0x05, 0x7f, 0xf4, 0x63, 0xc9, 0x02, 0x02, 0x5b, 0xbd, 0x58, 0xcb, 0x19, - 0xce, 0xf7, 0xcd, 0x90, 0x33, 0xc3, 0x31, 0x28, 0xb6, 0x51, 0x0f, 0x55, 0x71, 0x98, 0x54, 0x7b, - 0xcf, 0x02, 0x22, 0xd1, 0xb3, 0x6a, 0x8b, 0xc4, 0x44, 0x50, 0x51, 0x49, 0x38, 0x93, 0x0c, 0x16, - 0x94, 0xbe, 0x82, 0xc3, 0xa4, 0x62, 0xf5, 0x9b, 0x45, 0xcc, 0x44, 0x87, 0x89, 0x6a, 0x80, 0x04, - 0x19, 0x19, 0x61, 0x46, 0x63, 0x63, 0xb1, 0xb9, 0x61, 0xf4, 0xbe, 0x5e, 0x55, 0xcd, 0xc2, 0xaa, - 0xd6, 0x5b, 0xac, 0xc5, 0x8c, 0x5c, 0x7d, 0x59, 0x69, 0xa9, 0xc5, 0x58, 0x2b, 0x22, 0x55, 0xbd, - 0x0a, 0xba, 0xcd, 0xaa, 0xa4, 0x1d, 0x22, 0x24, 0xea, 0x24, 0x76, 0xc3, 0xe6, 0x8c, 0x8f, 0xca, - 0x1f, 0xad, 0xdb, 0xfa, 0x23, 0x05, 0xb2, 0xaf, 0x8c, 0xc7, 0x47, 0x12, 0x49, 0x02, 0x5f, 0x80, - 0x95, 0x04, 0x71, 0xd4, 0x11, 0xae, 0x53, 0x76, 0xb6, 0x57, 0x9f, 0xbb, 0x95, 0xe9, 0x08, 0x2a, - 0x0d, 0xad, 0xaf, 0xa5, 0xde, 0xf5, 0x4b, 0x4b, 0x9e, 0xdd, 0x0d, 0x5f, 0x82, 0x14, 0x0e, 0x13, - 0xe1, 0x2e, 0x97, 0xef, 0x6c, 0xaf, 0x3e, 0x7f, 0x38, 0x6b, 0xb5, 0x57, 0x6f, 0xd4, 0xd6, 0x95, - 0xc9, 0xa0, 0x5f, 0x4a, 0xed, 0xd5, 0x1b, 0xe2, 0xed, 0x85, 0xf9, 0xf5, 0xb4, 0x21, 0x7c, 0x05, - 0xd2, 0x21, 0x49, 0x98, 0xa0, 0x52, 0xb8, 0x77, 0x34, 0xc8, 0xc6, 0x2c, 0x48, 0xdd, 0xec, 0xa8, - 0x15, 0x14, 0xd0, 0xdb, 0x8b, 0x52, 0xda, 0x0a, 0x84, 0x37, 0x32, 0x86, 0x5f, 0x82, 0xbc, 0x90, - 0x88, 0x4b, 0x1a, 0xb7, 0x7c, 0x1c, 0x26, 0x3e, 0x0d, 0xdd, 0x54, 0xd9, 0xd9, 0x4e, 0xd5, 0xd6, - 0x06, 0xfd, 0xd2, 0xfd, 0x23, 0xab, 0xda, 0x0b, 0x93, 0x83, 0xba, 0x77, 0x5f, 0x4c, 0x2c, 0x43, - 0xf8, 0x11, 0x00, 0x21, 0x09, 0xa4, 0x1f, 0x92, 0x98, 0x75, 0xdc, 0xbb, 0x65, 0x67, 0x3b, 0xe3, - 0x65, 0x94, 0xa4, 0xae, 0x04, 0xf0, 0x09, 0xc8, 0xb4, 0x58, 0xcf, 0x6a, 0x57, 0xb4, 0x36, 0xdd, - 0x62, 0x3d, 0xa3, 0xfc, 0xc9, 0x01, 0x4f, 0x12, 0x4e, 0x7a, 0x94, 0x75, 0x85, 0x8f, 0x30, 0xee, - 0x76, 0xba, 0x11, 0x92, 0x94, 0xc5, 0xbe, 0xbe, 0x0f, 0xf7, 0x9e, 0x8e, 0xe9, 0xf3, 0xd9, 0x98, - 0xec, 0xf1, 0xef, 0x4e, 0x98, 0x1c, 0xd3, 0x0e, 0xa9, 0x95, 0x6d, 0x8c, 0xee, 0x9c, 0x0d, 0xc2, - 0xdb, 0x18, 0xf2, 0xcd, 0xa8, 0x20, 0x07, 0x05, 0xc9, 0x24, 0x8a, 0xfc, 0x84, 0xd3, 0x18, 0xd3, - 0x04, 0x45, 0xc2, 0x4d, 0x6b, 0x0f, 0x9e, 0xce, 0xf5, 0xe0, 0x58, 0x19, 0x34, 0x86, 0xfb, 0x6b, - 0x45, 0xcb, 0xff, 0xe8, 0x5a, 0xb5, 0xf0, 0xf2, 0xf2, 0xaa, 0x60, 0xeb, 0xdf, 0xbb, 0x60, 0xc5, - 0xe4, 0x06, 0x3c, 0x01, 0x6b, 0x98, 0x45, 0x11, 0x92, 0x84, 0x2b, 0x1f, 0x86, 0x09, 0xa5, 0xf8, - 0x3f, 0xbe, 0x26, 0x35, 0x46, 0x5b, 0xb5, 0x79, 0xcd, 0xb5, 0xcc, 0x85, 0x29, 0x85, 0xf0, 0x0a, - 0x78, 0x4a, 0x02, 0xbf, 0xb1, 0x57, 0xa6, 0x39, 0xdc, 0x65, 0x9d, 0xb3, 0x4f, 0xae, 0x4b, 0x9c, - 0x40, 0x1a, 0x70, 0x93, 0xb6, 0xfa, 0x56, 0xb5, 0x00, 0xbe, 0x06, 0x6b, 0xad, 0x88, 0x05, 0x28, - 0xf2, 0x35, 0x50, 0x44, 0x3b, 0x54, 0xba, 0x77, 0x34, 0xd0, 0x46, 0xc5, 0xd6, 0x9f, 0x2a, 0xd6, - 0x09, 0x77, 0x69, 0x6c, 0x61, 0xf2, 0xc6, 0x52, 0xa1, 0x1f, 0x2a, 0x3b, 0x78, 0x0a, 0x36, 0x44, - 0x97, 0x27, 0x91, 0xca, 0x81, 0x2e, 0x36, 0xd7, 0x7f, 0xc2, 0x89, 0x38, 0x61, 0x91, 0x49, 0xc3, - 0x4c, 0xed, 0x2b, 0x65, 0xf9, 0x77, 0xbf, 0xf4, 0x59, 0x8b, 0xca, 0x93, 0x6e, 0x50, 0xc1, 0xac, - 0x63, 0xcb, 0xdc, 0xfe, 0xec, 0x88, 0xb0, 0x5d, 0x95, 0x67, 0x09, 0x11, 0x95, 0x83, 0x58, 0xfe, - 0xf9, 0xfb, 0x0e, 0xb0, 0x5e, 0x1c, 0xc4, 0xd2, 0x7b, 0x6c, 0xe1, 0x77, 0x0d, 0xfa, 0xf1, 0x10, - 0x1c, 0x46, 0xe0, 0xc1, 0x34, 0x73, 0xc4, 0xa4, 0x49, 0xe2, 0x5b, 0x72, 0xae, 0x5d, 0xe5, 0x3c, - 0x64, 0x12, 0x72, 0xf0, 0x48, 0x9f, 0xd6, 0x6c, 0x90, 0x2b, 0x0b, 0x20, 0x5c, 0x57, 0xd8, 0x33, - 0x11, 0x36, 0x41, 0xe1, 0x0a, 0xa7, 0x0a, 0xef, 0xde, 0x02, 0xd8, 0x72, 0x13, 0x6c, 0x2a, 0xb6, - 0xa7, 0x20, 0x8f, 0x29, 0xc7, 0x5d, 0x2a, 0xfd, 0x80, 0x13, 0xd4, 0x26, 0xdc, 0x4d, 0x97, 0x9d, - 0xed, 0xb4, 0x97, 0xb3, 0xe2, 0x9a, 0x91, 0x6e, 0xfd, 0xba, 0x0c, 0x32, 0xa3, 0xc4, 0x82, 0xeb, - 0xe0, 0xae, 0xe9, 0x0c, 0x8e, 0xee, 0x0c, 0x66, 0xa1, 0xc0, 0x38, 0x69, 0x12, 0x4e, 0x62, 0x4c, - 0x7c, 0x24, 0x04, 0x91, 0x3a, 0x49, 0x33, 0x5e, 0x6e, 0x24, 0xde, 0x55, 0x52, 0x48, 0x55, 0xc9, - 0xc4, 0x3d, 0xc2, 0x85, 0x8a, 0xad, 0x89, 0xb0, 0x64, 0x5c, 0xa7, 0xe1, 0x6d, 0xc3, 0x2b, 0x8c, - 0x61, 0xf7, 0x35, 0x2a, 0xfc, 0xde, 0xd6, 0x4c, 0x33, 0x62, 0x8c, 0x2f, 0x24, 0x2b, 0x75, 0x39, - 0xed, 0x2b, 0xb8, 0xad, 0x5f, 0xd2, 0x20, 0x3f, 0x55, 0xb7, 0x73, 0x8e, 0x06, 0x82, 0x94, 0xc2, - 0xb3, 0xe7, 0xa1, 0xbf, 0xd5, 0x29, 0x44, 0xf4, 0x87, 0x2e, 0x0d, 0x4d, 0xeb, 0xe4, 0xea, 0xe7, - 0x06, 0xa7, 0x50, 0x27, 0x78, 0xc2, 0xc3, 0x3a, 0xc1, 0x5e, 0x61, 0x02, 0xd6, 0x53, 0x7f, 0xe1, - 0xd7, 0xf6, 0x14, 0x4c, 0xc1, 0xa7, 0x3e, 0xac, 0xe0, 0x75, 0xa0, 0xa6, 0xd4, 0x11, 0x50, 0xaf, - 0x47, 0x40, 0x23, 0x2a, 0xcf, 0xfc, 0x26, 0x21, 0x37, 0x28, 0xb5, 0x59, 0x37, 0xb3, 0x23, 0xc8, - 0x7d, 0x42, 0xa0, 0x0f, 0xb2, 0xc3, 0x64, 0x17, 0xf4, 0x9c, 0x2c, 0xa4, 0xb6, 0x56, 0x2d, 0xe2, - 0x11, 0x3d, 0x27, 0xb0, 0x03, 0x1e, 0x4c, 0x1e, 0x77, 0x42, 0x62, 0x14, 0xc9, 0xb3, 0x1b, 0x54, - 0xd5, 0x6c, 0x24, 0x70, 0x02, 0xb8, 0x61, 0x70, 0xe1, 0x0b, 0x90, 0x13, 0x09, 0x93, 0x7e, 0x07, - 0xf1, 0x36, 0x91, 0xea, 0x65, 0x4e, 0x6b, 0xa6, 0xc2, 0xa0, 0x5f, 0xca, 0x1e, 0x25, 0x4c, 0x7e, - 0xab, 0x15, 0x07, 0x75, 0x2f, 0x2b, 0xc6, 0xab, 0x10, 0xbe, 0x06, 0x0f, 0x27, 0xdd, 0x1c, 0x9b, - 0x67, 0xb4, 0xf9, 0xe3, 0x41, 0xbf, 0xf4, 0xe0, 0x70, 0xbc, 0x61, 0x84, 0x32, 0x19, 0xdc, 0x08, - 0xac, 0x07, 0xdc, 0x36, 0x21, 0x09, 0xe1, 0x3e, 0x27, 0x3f, 0x22, 0x1e, 0xfa, 0x09, 0xe1, 0x98, - 0xc4, 0x12, 0xb5, 0x88, 0x0b, 0x16, 0x10, 0xf8, 0x23, 0x83, 0xee, 0x69, 0xf0, 0xc6, 0x08, 0x5b, - 0x0d, 0x08, 0x9f, 0xe0, 0x13, 0x82, 0xdb, 0xfe, 0xf8, 0x11, 0xa3, 0xe7, 0x26, 0x22, 0x1a, 0x87, - 0xe4, 0xd4, 0xc7, 0xac, 0x1b, 0x4b, 0x77, 0x75, 0x01, 0x97, 0x5c, 0xd6, 0x44, 0x7b, 0xd3, 0x3c, - 0x07, 0x8a, 0x66, 0x4f, 0xb1, 0x5c, 0xdf, 0x6e, 0xb2, 0xff, 0x47, 0xbb, 0xd9, 0xfa, 0x79, 0x19, - 0x3c, 0x9e, 0x33, 0xc3, 0xe8, 0x5e, 0x3b, 0x1e, 0x14, 0x74, 0x3b, 0x30, 0x3d, 0x22, 0x37, 0x16, - 0x1f, 0xab, 0xc6, 0x10, 0x80, 0xcd, 0xf9, 0xd3, 0x95, 0x7d, 0xf7, 0x37, 0x2b, 0x66, 0x14, 0xae, - 0x0c, 0x47, 0xe1, 0xca, 0xf1, 0x70, 0x14, 0xae, 0xa5, 0x55, 0x50, 0x6f, 0x2e, 0x4a, 0x8e, 0xe7, - 0xce, 0x9b, 0x9a, 0x20, 0x01, 0x79, 0x1a, 0x4b, 0xc2, 0x89, 0x90, 0x37, 0x6f, 0xc0, 0xb3, 0x09, - 0x91, 0x1b, 0x82, 0xda, 0xf3, 0xf8, 0xcd, 0x01, 0x0f, 0xaf, 0x9d, 0xa9, 0x3e, 0xfc, 0x34, 0x08, - 0xc8, 0x4f, 0x8d, 0x77, 0xa6, 0x8b, 0xde, 0xf6, 0x25, 0xbc, 0x3a, 0xd2, 0xd5, 0x5e, 0xbe, 0x1b, - 0x14, 0x9d, 0xf7, 0x83, 0xa2, 0xf3, 0xcf, 0xa0, 0xe8, 0xbc, 0xb9, 0x2c, 0x2e, 0xbd, 0xbf, 0x2c, - 0x2e, 0xfd, 0x75, 0x59, 0x5c, 0xfa, 0xee, 0xd3, 0x09, 0x7c, 0x35, 0x6c, 0xed, 0x44, 0x28, 0x10, - 0xfa, 0xab, 0x7a, 0xaa, 0xff, 0xd5, 0xd0, 0x14, 0xc1, 0x8a, 0xbe, 0x89, 0x2f, 0xfe, 0x0b, 0x00, - 0x00, 0xff, 0xff, 0xe6, 0x31, 0x9b, 0x4e, 0x27, 0x0d, 0x00, 0x00, + // 1208 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xdd, 0x6e, 0x1a, 0xc7, + 0x17, 0xf7, 0xda, 0xc4, 0x81, 0xb1, 0x63, 0xf0, 0xc4, 0x49, 0xd6, 0x8e, 0xfe, 0xc0, 0xdf, 0x55, + 0x1b, 0x7a, 0x11, 0x50, 0x52, 0x29, 0x52, 0xa5, 0xa8, 0x69, 0xd6, 0x28, 0x11, 0x4a, 0x2a, 0xa1, + 0xb5, 0xaf, 0xda, 0x8b, 0xd5, 0xec, 0xec, 0x80, 0x47, 0x2c, 0x3b, 0xdb, 0x99, 0x81, 0x26, 0x79, + 0x85, 0xaa, 0x6a, 0xd4, 0x97, 0xa8, 0x14, 0xf5, 0xb2, 0x0f, 0x91, 0xde, 0x45, 0xbd, 0xaa, 0x7a, + 0x41, 0x2a, 0xf2, 0x22, 0xd5, 0x7c, 0x00, 0x6b, 0x30, 0x52, 0x64, 0xd3, 0x1b, 0x76, 0xe7, 0x7c, + 0xfc, 0xce, 0xc7, 0x9c, 0x73, 0xf6, 0x00, 0xca, 0x3d, 0x34, 0x44, 0x0d, 0x1c, 0xa5, 0x8d, 0xe1, + 0xbd, 0x90, 0x48, 0x74, 0xaf, 0xd1, 0x25, 0x09, 0x11, 0x54, 0xd4, 0x53, 0xce, 0x24, 0x83, 0x25, + 0xc5, 0xaf, 0xe3, 0x28, 0xad, 0x5b, 0xfe, 0x41, 0x19, 0x33, 0xd1, 0x67, 0xa2, 0x11, 0x22, 0x41, + 0xa6, 0x4a, 0x98, 0xd1, 0xc4, 0x68, 0x1c, 0xec, 0x1b, 0x7e, 0xa0, 0x4f, 0x0d, 0x73, 0xb0, 0xac, + 0xbd, 0x2e, 0xeb, 0x32, 0x43, 0x57, 0x6f, 0x96, 0x5a, 0xe9, 0x32, 0xd6, 0x8d, 0x49, 0x43, 0x9f, + 0xc2, 0x41, 0xa7, 0x21, 0x69, 0x9f, 0x08, 0x89, 0xfa, 0xa9, 0x15, 0x38, 0x58, 0xf0, 0x51, 0xf9, + 0xa3, 0x79, 0x87, 0x7f, 0xe4, 0xc0, 0xf6, 0x53, 0xe3, 0xf1, 0xb1, 0x44, 0x92, 0xc0, 0x07, 0x60, + 0x33, 0x45, 0x1c, 0xf5, 0x85, 0xeb, 0x54, 0x9d, 0xda, 0xd6, 0x7d, 0xb7, 0x3e, 0x1f, 0x41, 0xbd, + 0xad, 0xf9, 0x5e, 0xee, 0xed, 0xa8, 0xb2, 0xe6, 0x5b, 0x69, 0xf8, 0x08, 0xe4, 0x70, 0x94, 0x0a, + 0x77, 0xbd, 0xba, 0x51, 0xdb, 0xba, 0x7f, 0x63, 0x51, 0xeb, 0xa8, 0xd9, 0xf6, 0xf6, 0x94, 0xca, + 0x78, 0x54, 0xc9, 0x1d, 0x35, 0xdb, 0xe2, 0xcd, 0x7b, 0xf3, 0xf4, 0xb5, 0x22, 0x7c, 0x0a, 0xf2, + 0x11, 0x49, 0x99, 0xa0, 0x52, 0xb8, 0x1b, 0x1a, 0x64, 0x7f, 0x11, 0xa4, 0x69, 0x24, 0xbc, 0x92, + 0x02, 0x7a, 0xf3, 0xbe, 0x92, 0xb7, 0x04, 0xe1, 0x4f, 0x95, 0xe1, 0x97, 0xa0, 0x28, 0x24, 0xe2, + 0x92, 0x26, 0xdd, 0x00, 0x47, 0x69, 0x40, 0x23, 0x37, 0x57, 0x75, 0x6a, 0x39, 0x6f, 0x77, 0x3c, + 0xaa, 0x5c, 0x3b, 0xb6, 0xac, 0xa3, 0x28, 0x6d, 0x35, 0xfd, 0x6b, 0x22, 0x73, 0x8c, 0xe0, 0xff, + 0x00, 0x88, 0x48, 0x28, 0x83, 0x88, 0x24, 0xac, 0xef, 0x5e, 0xa9, 0x3a, 0xb5, 0x82, 0x5f, 0x50, + 0x94, 0xa6, 0x22, 0xc0, 0xdb, 0xa0, 0xd0, 0x65, 0x43, 0xcb, 0xdd, 0xd4, 0xdc, 0x7c, 0x97, 0x0d, + 0x0d, 0xf3, 0x47, 0x07, 0xdc, 0x4e, 0x39, 0x19, 0x52, 0x36, 0x10, 0x01, 0xc2, 0x78, 0xd0, 0x1f, + 0xc4, 0x48, 0x52, 0x96, 0x04, 0xfa, 0x3e, 0xdc, 0xab, 0x3a, 0xa6, 0xcf, 0x17, 0x63, 0xb2, 0xe9, + 0x7f, 0x9c, 0x51, 0x39, 0xa1, 0x7d, 0xe2, 0x55, 0x6d, 0x8c, 0xee, 0x12, 0x01, 0xe1, 0xef, 0x4f, + 0xec, 0x2d, 0xb0, 0x20, 0x07, 0x25, 0xc9, 0x24, 0x8a, 0x83, 0x94, 0xd3, 0x04, 0xd3, 0x14, 0xc5, + 0xc2, 0xcd, 0x6b, 0x0f, 0xee, 0x2c, 0xf5, 0xe0, 0x44, 0x29, 0xb4, 0x27, 0xf2, 0x5e, 0xd9, 0xda, + 0xbf, 0x79, 0x2e, 0x5b, 0xf8, 0x45, 0x79, 0x96, 0x70, 0xf8, 0xdb, 0x26, 0xd8, 0x34, 0xb5, 0x01, + 0x4f, 0xc1, 0x2e, 0x66, 0x71, 0x8c, 0x24, 0xe1, 0xca, 0x87, 0x49, 0x41, 0x29, 0xfb, 0xff, 0x3f, + 0xa7, 0x34, 0xa6, 0xa2, 0x5a, 0xdd, 0x73, 0xad, 0xe5, 0xd2, 0x1c, 0x43, 0xf8, 0x25, 0x3c, 0x47, + 0x81, 0x5f, 0xdb, 0x2b, 0xd3, 0x36, 0xdc, 0x75, 0x5d, 0xb3, 0xb7, 0xcf, 0x2b, 0x9c, 0x50, 0x1a, + 0x70, 0x53, 0xb6, 0xfa, 0x56, 0x35, 0x01, 0x3e, 0x03, 0xbb, 0xdd, 0x98, 0x85, 0x28, 0x0e, 0x34, + 0x50, 0x4c, 0xfb, 0x54, 0xba, 0x1b, 0x1a, 0x68, 0xbf, 0x6e, 0xfb, 0x4f, 0x35, 0x6b, 0xc6, 0x5d, + 0x9a, 0x58, 0x98, 0xa2, 0xd1, 0x54, 0xe8, 0xcf, 0x95, 0x1e, 0x7c, 0x01, 0xf6, 0xc5, 0x80, 0xa7, + 0xb1, 0xaa, 0x81, 0x01, 0x36, 0xd7, 0x7f, 0xca, 0x89, 0x38, 0x65, 0xb1, 0x29, 0xc3, 0x82, 0xf7, + 0x50, 0x69, 0xfe, 0x3d, 0xaa, 0x7c, 0xd6, 0xa5, 0xf2, 0x74, 0x10, 0xd6, 0x31, 0xeb, 0xdb, 0x36, + 0xb7, 0x8f, 0xbb, 0x22, 0xea, 0x35, 0xe4, 0xcb, 0x94, 0x88, 0x7a, 0x2b, 0x91, 0x7f, 0xfe, 0x7e, + 0x17, 0x58, 0x2f, 0x5a, 0x89, 0xf4, 0x6f, 0x59, 0xf8, 0xc7, 0x06, 0xfd, 0x64, 0x02, 0x0e, 0x63, + 0x70, 0x7d, 0xde, 0x72, 0xcc, 0xa4, 0x29, 0xe2, 0x4b, 0xda, 0xdc, 0x3d, 0x6b, 0xf3, 0x39, 0x93, + 0x90, 0x83, 0x9b, 0x3a, 0x5b, 0x8b, 0x41, 0x6e, 0xae, 0xc0, 0xe0, 0x9e, 0xc2, 0x5e, 0x88, 0xb0, + 0x03, 0x4a, 0x67, 0x6c, 0xaa, 0xf0, 0xae, 0xae, 0xc0, 0xda, 0x4e, 0xc6, 0x9a, 0x8a, 0xed, 0x0e, + 0x28, 0x62, 0xca, 0xf1, 0x80, 0xca, 0x20, 0xe4, 0x04, 0xf5, 0x08, 0x77, 0xf3, 0x55, 0xa7, 0x96, + 0xf7, 0x77, 0x2c, 0xd9, 0x33, 0x54, 0xf8, 0x10, 0x1c, 0xc4, 0xf4, 0xfb, 0x01, 0x8d, 0x4c, 0x9f, + 0x87, 0x31, 0xc3, 0xbd, 0x80, 0x26, 0x92, 0xf0, 0x21, 0x8a, 0xdd, 0x42, 0xd5, 0xa9, 0x6d, 0xf8, + 0x6e, 0x46, 0xc2, 0x53, 0x02, 0x2d, 0xcb, 0x3f, 0xfc, 0x65, 0x1d, 0x14, 0xa6, 0x65, 0x09, 0xf7, + 0xc0, 0x15, 0x33, 0x57, 0x1c, 0x3d, 0x57, 0xcc, 0x41, 0xb9, 0xc2, 0x49, 0x87, 0x70, 0x92, 0x60, + 0x12, 0x20, 0x21, 0x88, 0xd4, 0x25, 0x5e, 0xf0, 0x77, 0xa6, 0xe4, 0xc7, 0x8a, 0x0a, 0xa9, 0x6a, + 0xb8, 0x64, 0x48, 0xb8, 0x50, 0x9e, 0x74, 0x10, 0x96, 0x8c, 0xeb, 0x22, 0xbe, 0x6c, 0x72, 0x4a, + 0x33, 0xd8, 0x27, 0x1a, 0x15, 0x7e, 0x67, 0x3b, 0xae, 0x13, 0x33, 0xc6, 0x57, 0x52, 0xd3, 0xba, + 0x19, 0x9f, 0x28, 0xb8, 0xc3, 0x9f, 0xf3, 0xa0, 0x38, 0xd7, 0xf5, 0x4b, 0x52, 0x03, 0x41, 0x4e, + 0xe1, 0xd9, 0x7c, 0xe8, 0x77, 0x95, 0x85, 0xec, 0x85, 0x70, 0xf5, 0xb8, 0x40, 0x16, 0x9a, 0x04, + 0x67, 0x3c, 0x6c, 0x12, 0xec, 0x97, 0x32, 0xb0, 0xbe, 0xfa, 0x85, 0x5f, 0xd9, 0x2c, 0x98, 0x71, + 0x91, 0xfb, 0xb8, 0x71, 0xa1, 0x03, 0x35, 0x83, 0x02, 0x01, 0xf5, 0xed, 0x09, 0x69, 0x4c, 0xe5, + 0xcb, 0xa0, 0x43, 0xc8, 0x05, 0x1a, 0x75, 0xd1, 0xcd, 0xed, 0x29, 0xe4, 0x13, 0x42, 0x60, 0x00, + 0xb6, 0x27, 0xad, 0x22, 0xe8, 0x2b, 0xb2, 0x92, 0xce, 0xdc, 0xb2, 0x88, 0xc7, 0xf4, 0x15, 0x81, + 0x7d, 0x70, 0x3d, 0x9b, 0xee, 0x94, 0x24, 0x28, 0x96, 0x2f, 0x2f, 0xd0, 0x93, 0x8b, 0x91, 0xc0, + 0x0c, 0x70, 0xdb, 0xe0, 0xc2, 0x07, 0x60, 0x47, 0xa4, 0x4c, 0x06, 0x7d, 0xc4, 0x7b, 0x44, 0xaa, + 0xef, 0x7a, 0x5e, 0x5b, 0x2a, 0x8d, 0x47, 0x95, 0xed, 0xe3, 0x94, 0xc9, 0x6f, 0x34, 0xa3, 0xd5, + 0xf4, 0xb7, 0xc5, 0xec, 0x14, 0xc1, 0x67, 0xe0, 0x46, 0xd6, 0xcd, 0x99, 0x7a, 0x41, 0xab, 0xdf, + 0x1a, 0x8f, 0x2a, 0xd7, 0x9f, 0xcf, 0x04, 0xa6, 0x28, 0xd9, 0xe0, 0xa6, 0x60, 0x43, 0xe0, 0xf6, + 0x08, 0x49, 0x09, 0x0f, 0x38, 0xf9, 0x01, 0xf1, 0x28, 0x48, 0x09, 0xc7, 0x24, 0x91, 0xa8, 0x4b, + 0x5c, 0xb0, 0x82, 0xc0, 0x6f, 0x1a, 0x74, 0x5f, 0x83, 0xb7, 0xa7, 0xd8, 0x6a, 0xbd, 0xf8, 0x04, + 0x9f, 0x12, 0xdc, 0x0b, 0x66, 0x9f, 0x40, 0xfa, 0xca, 0x44, 0x44, 0x93, 0x88, 0xbc, 0x08, 0x30, + 0x1b, 0x24, 0xd2, 0xdd, 0x5a, 0xc1, 0x25, 0x57, 0xb5, 0xa1, 0xa3, 0x79, 0x3b, 0x2d, 0x65, 0xe6, + 0x48, 0x59, 0x39, 0x7f, 0xdc, 0x6c, 0xff, 0x17, 0xe3, 0xe6, 0xf0, 0xa7, 0x75, 0x70, 0x6b, 0xc9, + 0x06, 0xa4, 0x27, 0xf5, 0x6c, 0xcd, 0xd0, 0xe3, 0xc0, 0xcc, 0x88, 0x9d, 0x19, 0xf9, 0x44, 0x0d, + 0x86, 0x10, 0x1c, 0x2c, 0xdf, 0xcd, 0xec, 0xd6, 0x70, 0x50, 0x37, 0x8b, 0x74, 0x7d, 0xb2, 0x48, + 0xd7, 0x4f, 0x26, 0x8b, 0xb4, 0x97, 0x57, 0x41, 0xbd, 0x7e, 0x5f, 0x71, 0x7c, 0x77, 0xd9, 0xce, + 0x05, 0x09, 0x28, 0xea, 0xd9, 0x4f, 0x84, 0xbc, 0xf8, 0x00, 0x5e, 0x2c, 0x88, 0x9d, 0x09, 0xa8, + 0xcd, 0xc7, 0xaf, 0x0e, 0xb8, 0x71, 0xee, 0x46, 0xf6, 0xf1, 0xd9, 0x20, 0xa0, 0x38, 0xb7, 0x1c, + 0x9a, 0x29, 0x7a, 0xd9, 0xef, 0xe8, 0xd9, 0x85, 0xd0, 0x7b, 0xf4, 0x76, 0x5c, 0x76, 0xde, 0x8d, + 0xcb, 0xce, 0x3f, 0xe3, 0xb2, 0xf3, 0xfa, 0x43, 0x79, 0xed, 0xdd, 0x87, 0xf2, 0xda, 0x5f, 0x1f, + 0xca, 0x6b, 0xdf, 0x7e, 0x9a, 0xc1, 0x57, 0xab, 0xda, 0xdd, 0x18, 0x85, 0x42, 0xbf, 0x35, 0x5e, + 0xe8, 0x3f, 0x2a, 0xda, 0x44, 0xb8, 0xa9, 0x6f, 0xe2, 0x8b, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, + 0x5c, 0xdf, 0x27, 0x18, 0x65, 0x0d, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -661,6 +671,11 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.LiquidationBlockInterval != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.LiquidationBlockInterval)) + i-- + dAtA[i] = 0x48 + } if m.CircuitBreaker { i-- if m.CircuitBreaker { @@ -1108,6 +1123,9 @@ func (m *Params) Size() (n int) { if m.CircuitBreaker { n += 2 } + if m.LiquidationBlockInterval != 0 { + n += 1 + sovGenesis(uint64(m.LiquidationBlockInterval)) + } return n } @@ -1798,6 +1816,25 @@ func (m *Params) Unmarshal(dAtA []byte) error { } } m.CircuitBreaker = bool(v != 0) + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LiquidationBlockInterval", wireType) + } + m.LiquidationBlockInterval = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LiquidationBlockInterval |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipGenesis(dAtA[iNdEx:]) diff --git a/x/cdp/types/params.go b/x/cdp/types/params.go index fd3ca4c6..ca3356fb 100644 --- a/x/cdp/types/params.go +++ b/x/cdp/types/params.go @@ -13,18 +13,19 @@ import ( // Parameter keys var ( - KeyGlobalDebtLimit = []byte("GlobalDebtLimit") - KeyCollateralParams = []byte("CollateralParams") - KeyDebtParam = []byte("DebtParam") - KeyCircuitBreaker = []byte("CircuitBreaker") - KeyDebtThreshold = []byte("DebtThreshold") - KeyDebtLot = []byte("DebtLot") - KeySurplusThreshold = []byte("SurplusThreshold") - KeySurplusLot = []byte("SurplusLot") - DefaultGlobalDebt = sdk.NewCoin(DefaultStableDenom, sdk.ZeroInt()) - DefaultCircuitBreaker = false - DefaultCollateralParams = CollateralParams{} - DefaultDebtParam = DebtParam{ + KeyGlobalDebtLimit = []byte("GlobalDebtLimit") + KeyCollateralParams = []byte("CollateralParams") + KeyDebtParam = []byte("DebtParam") + KeyCircuitBreaker = []byte("CircuitBreaker") + KeyDebtThreshold = []byte("DebtThreshold") + KeyDebtLot = []byte("DebtLot") + KeySurplusThreshold = []byte("SurplusThreshold") + KeySurplusLot = []byte("SurplusLot") + KeyBeginBlockerExecutionBlockInterval = []byte("BeginBlockerExecutionBlockInterval") + DefaultGlobalDebt = sdk.NewCoin(DefaultStableDenom, sdk.ZeroInt()) + DefaultCircuitBreaker = false + DefaultCollateralParams = CollateralParams{} + DefaultDebtParam = DebtParam{ Denom: "usdx", ReferenceAsset: "usd", ConversionFactor: sdkmath.NewInt(6), @@ -39,22 +40,25 @@ var ( DefaultSurplusLot = sdkmath.NewInt(10000000000) DefaultDebtLot = sdkmath.NewInt(10000000000) stabilityFeeMax = sdk.MustNewDecFromStr("1.000000051034942716") // 500% APR + // Run every block + DefaultBeginBlockerExecutionBlockInterval = int64(1) ) // NewParams returns a new params object func NewParams( debtLimit sdk.Coin, collateralParams CollateralParams, debtParam DebtParam, surplusThreshold, - surplusLot, debtThreshold, debtLot sdkmath.Int, breaker bool, + surplusLot, debtThreshold, debtLot sdkmath.Int, breaker bool, beginBlockerExecutionBlockInterval int64, ) Params { return Params{ - GlobalDebtLimit: debtLimit, - CollateralParams: collateralParams, - DebtParam: debtParam, - SurplusAuctionThreshold: surplusThreshold, - SurplusAuctionLot: surplusLot, - DebtAuctionThreshold: debtThreshold, - DebtAuctionLot: debtLot, - CircuitBreaker: breaker, + GlobalDebtLimit: debtLimit, + CollateralParams: collateralParams, + DebtParam: debtParam, + SurplusAuctionThreshold: surplusThreshold, + SurplusAuctionLot: surplusLot, + DebtAuctionThreshold: debtThreshold, + DebtAuctionLot: debtLot, + CircuitBreaker: breaker, + LiquidationBlockInterval: beginBlockerExecutionBlockInterval, } } @@ -63,7 +67,7 @@ func DefaultParams() Params { return NewParams( DefaultGlobalDebt, DefaultCollateralParams, DefaultDebtParam, DefaultSurplusThreshold, DefaultSurplusLot, DefaultDebtThreshold, DefaultDebtLot, - DefaultCircuitBreaker, + DefaultCircuitBreaker, DefaultBeginBlockerExecutionBlockInterval, ) } @@ -122,6 +126,7 @@ func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { paramtypes.NewParamSetPair(KeySurplusLot, &p.SurplusAuctionLot, validateSurplusAuctionLotParam), paramtypes.NewParamSetPair(KeyDebtThreshold, &p.DebtAuctionThreshold, validateDebtAuctionThresholdParam), paramtypes.NewParamSetPair(KeyDebtLot, &p.DebtAuctionLot, validateDebtAuctionLotParam), + paramtypes.NewParamSetPair(KeyBeginBlockerExecutionBlockInterval, &p.LiquidationBlockInterval, validateBeginBlockerExecutionBlockIntervalParam), } } @@ -143,6 +148,10 @@ func (p Params) Validate() error { return err } + if err := validateBeginBlockerExecutionBlockIntervalParam(p.LiquidationBlockInterval); err != nil { + return err + } + if err := validateSurplusAuctionThresholdParam(p.SurplusAuctionThreshold); err != nil { return err } @@ -346,3 +355,16 @@ func validateDebtAuctionLotParam(i interface{}) error { return nil } + +func validateBeginBlockerExecutionBlockIntervalParam(i interface{}) error { + bbebi, ok := i.(int64) + if !ok { + return fmt.Errorf("invalid parameter type: %T", i) + } + + if bbebi <= 0 { + return fmt.Errorf("begin blocker execution block interval param should be positive: %d", bbebi) + } + + return nil +} diff --git a/x/cdp/types/params_test.go b/x/cdp/types/params_test.go index 36b7f127..0dd72767 100644 --- a/x/cdp/types/params_test.go +++ b/x/cdp/types/params_test.go @@ -20,14 +20,15 @@ func (suite *ParamsTestSuite) SetupTest() { func (suite *ParamsTestSuite) TestParamValidation() { type args struct { - globalDebtLimit sdk.Coin - collateralParams types.CollateralParams - debtParam types.DebtParam - surplusThreshold sdkmath.Int - surplusLot sdkmath.Int - debtThreshold sdkmath.Int - debtLot sdkmath.Int - breaker bool + globalDebtLimit sdk.Coin + collateralParams types.CollateralParams + debtParam types.DebtParam + surplusThreshold sdkmath.Int + surplusLot sdkmath.Int + debtThreshold sdkmath.Int + debtLot sdkmath.Int + breaker bool + beginBlockerExecutionBlockInterval int64 } type errArgs struct { expectPass bool @@ -42,14 +43,15 @@ func (suite *ParamsTestSuite) TestParamValidation() { { name: "default", args: args{ - globalDebtLimit: types.DefaultGlobalDebt, - collateralParams: types.DefaultCollateralParams, - debtParam: types.DefaultDebtParam, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + globalDebtLimit: types.DefaultGlobalDebt, + collateralParams: types.DefaultCollateralParams, + debtParam: types.DefaultDebtParam, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: true, @@ -82,11 +84,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: true, @@ -119,11 +122,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -156,11 +160,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -207,11 +212,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: true, @@ -258,11 +264,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -309,11 +316,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -345,11 +353,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -382,11 +391,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -433,11 +443,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -484,11 +495,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: true, @@ -521,11 +533,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -558,11 +571,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -595,11 +609,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -632,11 +647,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -663,12 +679,13 @@ func (suite *ParamsTestSuite) TestParamValidation() { CheckCollateralizationIndexCount: sdkmath.NewInt(10), }, }, - debtParam: types.DefaultDebtParam, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + debtParam: types.DefaultDebtParam, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -701,11 +718,12 @@ func (suite *ParamsTestSuite) TestParamValidation() { ConversionFactor: sdkmath.NewInt(6), DebtFloor: sdkmath.NewInt(10000000), }, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -715,14 +733,15 @@ func (suite *ParamsTestSuite) TestParamValidation() { { name: "nil debt limit", args: args{ - globalDebtLimit: sdk.Coin{}, - collateralParams: types.DefaultCollateralParams, - debtParam: types.DefaultDebtParam, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + globalDebtLimit: sdk.Coin{}, + collateralParams: types.DefaultCollateralParams, + debtParam: types.DefaultDebtParam, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -732,14 +751,15 @@ func (suite *ParamsTestSuite) TestParamValidation() { { name: "zero surplus auction threshold", args: args{ - globalDebtLimit: types.DefaultGlobalDebt, - collateralParams: types.DefaultCollateralParams, - debtParam: types.DefaultDebtParam, - surplusThreshold: sdk.ZeroInt(), - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + globalDebtLimit: types.DefaultGlobalDebt, + collateralParams: types.DefaultCollateralParams, + debtParam: types.DefaultDebtParam, + surplusThreshold: sdk.ZeroInt(), + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -749,14 +769,15 @@ func (suite *ParamsTestSuite) TestParamValidation() { { name: "zero debt auction threshold", args: args{ - globalDebtLimit: types.DefaultGlobalDebt, - collateralParams: types.DefaultCollateralParams, - debtParam: types.DefaultDebtParam, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: sdk.ZeroInt(), - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + globalDebtLimit: types.DefaultGlobalDebt, + collateralParams: types.DefaultCollateralParams, + debtParam: types.DefaultDebtParam, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: sdk.ZeroInt(), + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -766,14 +787,15 @@ func (suite *ParamsTestSuite) TestParamValidation() { { name: "zero surplus auction lot", args: args{ - globalDebtLimit: types.DefaultGlobalDebt, - collateralParams: types.DefaultCollateralParams, - debtParam: types.DefaultDebtParam, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: sdk.ZeroInt(), - debtThreshold: types.DefaultDebtThreshold, - debtLot: types.DefaultDebtLot, - breaker: types.DefaultCircuitBreaker, + globalDebtLimit: types.DefaultGlobalDebt, + collateralParams: types.DefaultCollateralParams, + debtParam: types.DefaultDebtParam, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: sdk.ZeroInt(), + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, @@ -783,24 +805,61 @@ func (suite *ParamsTestSuite) TestParamValidation() { { name: "zero debt auction lot", args: args{ - globalDebtLimit: types.DefaultGlobalDebt, - collateralParams: types.DefaultCollateralParams, - debtParam: types.DefaultDebtParam, - surplusThreshold: types.DefaultSurplusThreshold, - surplusLot: types.DefaultSurplusLot, - debtThreshold: types.DefaultDebtThreshold, - debtLot: sdk.ZeroInt(), - breaker: types.DefaultCircuitBreaker, + globalDebtLimit: types.DefaultGlobalDebt, + collateralParams: types.DefaultCollateralParams, + debtParam: types.DefaultDebtParam, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: sdk.ZeroInt(), + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: types.DefaultBeginBlockerExecutionBlockInterval, }, errArgs: errArgs{ expectPass: false, contains: "debt auction lot should be positive", }, }, + { + name: "zero begin blocker execution interval", + args: args{ + globalDebtLimit: types.DefaultGlobalDebt, + collateralParams: types.DefaultCollateralParams, + debtParam: types.DefaultDebtParam, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: 0, + }, + errArgs: errArgs{ + expectPass: false, + contains: "begin blocker execution block interval param should be positive", + }, + }, + { + name: "negative begin blocker execution interval", + args: args{ + globalDebtLimit: types.DefaultGlobalDebt, + collateralParams: types.DefaultCollateralParams, + debtParam: types.DefaultDebtParam, + surplusThreshold: types.DefaultSurplusThreshold, + surplusLot: types.DefaultSurplusLot, + debtThreshold: types.DefaultDebtThreshold, + debtLot: types.DefaultDebtLot, + breaker: types.DefaultCircuitBreaker, + beginBlockerExecutionBlockInterval: -1, + }, + errArgs: errArgs{ + expectPass: false, + contains: "begin blocker execution block interval param should be positive", + }, + }, } for _, tc := range testCases { suite.Run(tc.name, func() { - params := types.NewParams(tc.args.globalDebtLimit, tc.args.collateralParams, tc.args.debtParam, tc.args.surplusThreshold, tc.args.surplusLot, tc.args.debtThreshold, tc.args.debtLot, tc.args.breaker) + params := types.NewParams(tc.args.globalDebtLimit, tc.args.collateralParams, tc.args.debtParam, tc.args.surplusThreshold, tc.args.surplusLot, tc.args.debtThreshold, tc.args.debtLot, tc.args.breaker, tc.args.beginBlockerExecutionBlockInterval) err := params.Validate() if tc.errArgs.expectPass { suite.Require().NoError(err) diff --git a/x/community/testutil/cdp_genesis.go b/x/community/testutil/cdp_genesis.go index 160d61c2..3b4ef80d 100644 --- a/x/community/testutil/cdp_genesis.go +++ b/x/community/testutil/cdp_genesis.go @@ -13,11 +13,12 @@ import ( func NewCDPGenState(cdc codec.JSONCodec, denom, asset string, liquidationRatio sdk.Dec) app.GenesisState { cdpGenesis := cdptypes.GenesisState{ Params: cdptypes.Params{ - GlobalDebtLimit: sdk.NewInt64Coin("usdx", 1000000000000), - SurplusAuctionThreshold: cdptypes.DefaultSurplusThreshold, - SurplusAuctionLot: cdptypes.DefaultSurplusLot, - DebtAuctionThreshold: cdptypes.DefaultDebtThreshold, - DebtAuctionLot: cdptypes.DefaultDebtLot, + GlobalDebtLimit: sdk.NewInt64Coin("usdx", 1000000000000), + SurplusAuctionThreshold: cdptypes.DefaultSurplusThreshold, + SurplusAuctionLot: cdptypes.DefaultSurplusLot, + DebtAuctionThreshold: cdptypes.DefaultDebtThreshold, + DebtAuctionLot: cdptypes.DefaultDebtLot, + LiquidationBlockInterval: cdptypes.DefaultBeginBlockerExecutionBlockInterval, CollateralParams: cdptypes.CollateralParams{ { Denom: denom, diff --git a/x/incentive/integration_test.go b/x/incentive/integration_test.go index c7a855b2..f1d5039d 100644 --- a/x/incentive/integration_test.go +++ b/x/incentive/integration_test.go @@ -23,11 +23,12 @@ func c(denom string, amount int64) sdk.Coin { return sdk.NewInt64Coin(denom, amo func NewCDPGenStateMulti(cdc codec.JSONCodec) app.GenesisState { cdpGenesis := cdptypes.GenesisState{ Params: cdptypes.Params{ - GlobalDebtLimit: sdk.NewInt64Coin("usdx", 2000000000000), - SurplusAuctionThreshold: cdptypes.DefaultSurplusThreshold, - SurplusAuctionLot: cdptypes.DefaultSurplusLot, - DebtAuctionThreshold: cdptypes.DefaultDebtThreshold, - DebtAuctionLot: cdptypes.DefaultDebtLot, + GlobalDebtLimit: sdk.NewInt64Coin("usdx", 2000000000000), + SurplusAuctionThreshold: cdptypes.DefaultSurplusThreshold, + SurplusAuctionLot: cdptypes.DefaultSurplusLot, + DebtAuctionThreshold: cdptypes.DefaultDebtThreshold, + DebtAuctionLot: cdptypes.DefaultDebtLot, + LiquidationBlockInterval: cdptypes.DefaultBeginBlockerExecutionBlockInterval, CollateralParams: cdptypes.CollateralParams{ { Denom: "xrp", diff --git a/x/incentive/keeper/integration_test.go b/x/incentive/keeper/integration_test.go index b45d7cc9..efc37169 100644 --- a/x/incentive/keeper/integration_test.go +++ b/x/incentive/keeper/integration_test.go @@ -29,11 +29,12 @@ func dcs(coins ...sdk.DecCoin) sdk.DecCoins { return sdk.NewDecCoins(coins...) } func NewCDPGenStateMulti(cdc codec.JSONCodec) app.GenesisState { cdpGenesis := cdptypes.GenesisState{ Params: cdptypes.Params{ - GlobalDebtLimit: sdk.NewInt64Coin("usdx", 2000000000000), - SurplusAuctionThreshold: cdptypes.DefaultSurplusThreshold, - SurplusAuctionLot: cdptypes.DefaultSurplusLot, - DebtAuctionThreshold: cdptypes.DefaultDebtThreshold, - DebtAuctionLot: cdptypes.DefaultDebtLot, + GlobalDebtLimit: sdk.NewInt64Coin("usdx", 2000000000000), + SurplusAuctionThreshold: cdptypes.DefaultSurplusThreshold, + SurplusAuctionLot: cdptypes.DefaultSurplusLot, + DebtAuctionThreshold: cdptypes.DefaultDebtThreshold, + DebtAuctionLot: cdptypes.DefaultDebtLot, + LiquidationBlockInterval: cdptypes.DefaultBeginBlockerExecutionBlockInterval, CollateralParams: cdptypes.CollateralParams{ { Denom: "xrp",