chore: add atom to default registry (#1371)

* add uatom to default oracle params

* Add atom to default leverage registry

* fix the leverage tests

* underscore

* --

* modify defaults

* change UMEE MaxCollateralShare from 1.0 to 0.3

* comment++

* comment++

* change umee max share back to 1.0

Co-authored-by: toteki <63419657+toteki@users.noreply.github.com>

app/test_helpers.go

@@ -236,31 +236,33 @@ func IntegrationTestNetworkConfig() network.Config {
 	// Start with the default genesis state
 	appGenState := ModuleBasics.DefaultGenesis(encCfg.Codec)
 
-	// Default genesis doesn't have tokens in Token registry, so here we add one:
+	// Override default leverage registry with one more suitable for testing
 	var leverageGenState leveragetypes.GenesisState
 	if err := cdc.UnmarshalJSON(appGenState[leveragetypes.ModuleName], &leverageGenState); err != nil {
 		panic(err)
 	}
-	leverageGenState.Registry = append(leverageGenState.Registry, leveragetypes.Token{
-		BaseDenom:              params.BondDenom,
-		SymbolDenom:            params.DisplayDenom,
-		Exponent:               6,
-		ReserveFactor:          sdk.MustNewDecFromStr("0.1"),
-		CollateralWeight:       sdk.MustNewDecFromStr("0.05"),
-		LiquidationThreshold:   sdk.MustNewDecFromStr("0.05"),
-		BaseBorrowRate:         sdk.MustNewDecFromStr("0.02"),
-		KinkBorrowRate:         sdk.MustNewDecFromStr("0.2"),
-		MaxBorrowRate:          sdk.MustNewDecFromStr("1.5"),
-		KinkUtilization:        sdk.MustNewDecFromStr("0.2"),
-		LiquidationIncentive:   sdk.MustNewDecFromStr("0.18"),
-		EnableMsgSupply:        true,
-		EnableMsgBorrow:        true,
-		Blacklist:              false,
-		MaxCollateralShare:     sdk.MustNewDecFromStr("1"),
-		MaxSupplyUtilization:   sdk.MustNewDecFromStr("1"),
-		MinCollateralLiquidity: sdk.MustNewDecFromStr("0"),
-		MaxSupply:              sdk.NewInt(100000000000),
-	})
+	leverageGenState.Registry = []leveragetypes.Token{
+		{
+			BaseDenom:              params.BondDenom,
+			SymbolDenom:            params.DisplayDenom,
+			Exponent:               6,
+			ReserveFactor:          sdk.MustNewDecFromStr("0.1"),
+			CollateralWeight:       sdk.MustNewDecFromStr("0.05"),
+			LiquidationThreshold:   sdk.MustNewDecFromStr("0.05"),
+			BaseBorrowRate:         sdk.MustNewDecFromStr("0.02"),
+			KinkBorrowRate:         sdk.MustNewDecFromStr("0.2"),
+			MaxBorrowRate:          sdk.MustNewDecFromStr("1.5"),
+			KinkUtilization:        sdk.MustNewDecFromStr("0.2"),
+			LiquidationIncentive:   sdk.MustNewDecFromStr("0.18"),
+			EnableMsgSupply:        true,
+			EnableMsgBorrow:        true,
+			Blacklist:              false,
+			MaxCollateralShare:     sdk.MustNewDecFromStr("1"),
+			MaxSupplyUtilization:   sdk.MustNewDecFromStr("1"),
+			MinCollateralLiquidity: sdk.MustNewDecFromStr("0"),
+			MaxSupply:              sdk.NewInt(100000000000),
+		},
+	}
 	bz, err := cdc.MarshalJSON(&leverageGenState)
 	if err != nil {
 		panic(err)

starport.ci.yml

@@ -7,44 +7,6 @@ genesis:
     staking:
       params:
         bond_denom: "uumee"
-    leverage:
-      registry:
-        - base_denom: "uumee"
-          symbol_denom: "UMEE"
-          exponent: 6
-          reserve_factor: "0.100000000000000000"
-          collateral_weight: "0.050000000000000000"
-          liquidation_threshold: "0.050000000000000000"
-          base_borrow_rate: "0.020000000000000000"
-          kink_borrow_rate: "0.200000000000000000"
-          max_borrow_rate: "1.50000000000000000"
-          kink_utilization: "0.200000000000000000"
-          liquidation_incentive: "0.180000000000000000"
-          enable_msg_supply: true
-          enable_msg_borrow: true
-          blacklist: false
-          max_collateral_share: "1.00000000000000000"
-          max_supply_utilization: "1.00000000000000000"
-          min_collateral_liquidity: "0.000000000000000000"
-          max_supply: "100000000000000000000"
-        - base_denom: "ibc/FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
-          symbol_denom: "ATOM"
-          exponent: 6
-          reserve_factor: "0.100000000000000000"
-          collateral_weight: "0.550000000000000000"
-          liquidation_threshold: "0.600000000000000000"
-          base_borrow_rate: "0.020000000000000000"
-          kink_borrow_rate: "0.200000000000000000"
-          max_borrow_rate: "1.50000000000000000"
-          kink_utilization: "0.200000000000000000"
-          liquidation_incentive: "0.180000000000000000"
-          enable_msg_supply: true
-          enable_msg_borrow: true
-          blacklist: false
-          max_collateral_share: "1.00000000000000000"
-          max_supply_utilization: "1.00000000000000000"
-          min_collateral_liquidity: "0.000000000000000000"
-          max_supply: "100000000000000000000"
     gravity:
       delegate_keys:
         - validator: "umeevaloper1zypqa76je7pxsdwkfah6mu9a583sju6xjettez"

x/leverage/client/tests/suite.go

@@ -12,8 +12,6 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/suite"
 	tmcli "github.com/tendermint/tendermint/libs/cli"
-
-	appparams "github.com/umee-network/umee/v3/app/params"
 )
 
 type IntegrationTestSuite struct {
@@ -82,7 +80,8 @@ func (t testTransaction) Run(s *IntegrationTestSuite) {
 		fmt.Sprintf("--%s=json", tmcli.OutputFlag),
 		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
 		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
-		fmt.Sprintf("--%s=%s", flags.FlagGasPrices, appparams.MinMinGasPrice),
+		fmt.Sprintf("--%s=%s", flags.FlagGas, "10000000"),
+		fmt.Sprintf("--%s=%s", flags.FlagFees, "1000000uumee"),
 	}
 
 	out, err := clitestutil.ExecTestCLICmd(clientCtx, t.command, append(t.args, txFlags...))

x/leverage/fixtures/params.go

@@ -0,0 +1,18 @@
+package fixtures
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/umee-network/umee/v3/x/leverage/types"
+)
+
+// Params returns leverage params used in testing.
+func Params() types.Params {
+	return types.Params{
+		CompleteLiquidationThreshold: sdk.MustNewDecFromStr("0.1"),
+		MinimumCloseFactor:           sdk.MustNewDecFromStr("0.01"),
+		OracleRewardFactor:           sdk.MustNewDecFromStr("0.01"),
+		SmallLiquidationSize:         sdk.MustNewDecFromStr("100.00"),
+		DirectLiquidationFee:         sdk.MustNewDecFromStr("0.1"),
+	}
+}

x/leverage/fixtures/token.go

@@ -7,8 +7,8 @@ import (
 )
 
 const (
-	// AtomDenom is an ibc denom to be used as ATOM's BaseDenom during testing
-	AtomDenom = "ibc/CDC4587874B85BEA4FCEC3CEA5A1195139799A1FEE711A07D972537E18FDA39D"
+	// AtomDenom is an ibc denom to be used as ATOM's BaseDenom during testing. Matches mainnet.
+	AtomDenom = "ibc/C4CFF46FD6DE35CA4CF4CE031E643C8FDC9BA4B99AE598E9B0ED98FE3A2319F9"
 )
 
 // Token returns a valid token

x/leverage/gov_handler_test.go

@@ -42,20 +42,19 @@ func TestUpdateRegistryProposalHandler(t *testing.T) {
 	})
 
 	t.Run("valid proposal", func(t *testing.T) {
-		require.NoError(t, k.SetTokenSettings(ctx,
-			fixtures.Token("uosmo", "OSMO"),
-		))
-		require.NoError(t, k.SetTokenSettings(ctx,
-			fixtures.Token("uatom", "ATOM"),
-		))
+		for _, token := range types.DefaultRegistry() {
+			require.NoError(t, k.SetTokenSettings(ctx, token))
+		}
+
+		modifiedUmee := fixtures.Token("uumee", "UMEE")
+		modifiedUmee.ReserveFactor = sdk.MustNewDecFromStr("0.69")
 
 		osmo := fixtures.Token("uosmo", "OSMO")
-		osmo.ReserveFactor = sdk.MustNewDecFromStr("0.3")
 		p := &types.UpdateRegistryProposal{
 			Title:       "test",
 			Description: "test",
 			Registry: []types.Token{
-				fixtures.Token("uumee", "UMEE"),
+				modifiedUmee,
 				osmo,
 			},
 		}
@@ -65,12 +64,15 @@ func TestUpdateRegistryProposalHandler(t *testing.T) {
 		tokens := k.GetAllRegisteredTokens(ctx)
 		require.Len(t, tokens, 3)
 
-		_, err := k.GetTokenSettings(ctx, "uumee")
+		token, err := k.GetTokenSettings(ctx, "uumee")
+		require.NoError(t, err)
+		require.Equal(t, "0.690000000000000000", token.ReserveFactor.String(),
+			"reserve factor is correctly set")
+
+		_, err = k.GetTokenSettings(ctx, "uosmo")
 		require.NoError(t, err)
 
-		token, err := k.GetTokenSettings(ctx, "uosmo")
+		_, err = k.GetTokenSettings(ctx, fixtures.AtomDenom)
 		require.NoError(t, err)
-		require.Equal(t, "0.300000000000000000", token.ReserveFactor.String(),
-			"reserve factor is correctly set")
 	})
 }

x/leverage/keeper/grpc_query_test.go

@@ -5,6 +5,7 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
+	"github.com/umee-network/umee/v3/x/leverage/fixtures"
 	"github.com/umee-network/umee/v3/x/leverage/keeper"
 	"github.com/umee-network/umee/v3/x/leverage/types"
 )
@@ -22,7 +23,7 @@ func (s *IntegrationTestSuite) TestQuerier_Params() {
 
 	resp, err := s.queryClient.Params(ctx.Context(), &types.QueryParams{})
 	require.NoError(err)
-	require.Equal(types.DefaultParams(), resp.Params)
+	require.Equal(fixtures.Params(), resp.Params)
 }
 
 func (s *IntegrationTestSuite) TestQuerier_MarketSummary() {

x/leverage/keeper/suite_test.go

@@ -52,9 +52,6 @@ func (s *IntegrationTestSuite) SetupTest() {
 	// Enable liquidation queries for testing
 	keeper.EnableLiquidator = "true"
 
-	umeeToken := newToken(appparams.BondDenom, "UMEE")
-	atomIBCToken := newToken(atomDenom, "ATOM")
-
 	// we only override the Leverage keeper so we can supply a custom mock oracle
 	k, tk := keeper.NewTestKeeper(
 		s.Require(),
@@ -69,9 +66,13 @@ func (s *IntegrationTestSuite) SetupTest() {
 	app.LeverageKeeper = k
 	app.LeverageKeeper = *app.LeverageKeeper.SetHooks(types.NewMultiHooks())
 
+	// override DefaultGenesis token registry with fixtures.Token
 	leverage.InitGenesis(ctx, app.LeverageKeeper, *types.DefaultGenesis())
-	require.NoError(app.LeverageKeeper.SetTokenSettings(ctx, umeeToken))
-	require.NoError(app.LeverageKeeper.SetTokenSettings(ctx, atomIBCToken))
+	require.NoError(app.LeverageKeeper.SetTokenSettings(ctx, newToken(appparams.BondDenom, "UMEE")))
+	require.NoError(app.LeverageKeeper.SetTokenSettings(ctx, newToken(atomDenom, "ATOM")))
+
+	// override DefaultGenesis params with fixtures.Params
+	app.LeverageKeeper.SetParams(ctx, fixtures.Params())
 
 	queryHelper := baseapp.NewQueryServerTestHelper(ctx, app.InterfaceRegistry())
 	types.RegisterQueryServer(queryHelper, keeper.NewQuerier(app.LeverageKeeper))

x/leverage/simulation/operations_test.go

@@ -127,7 +127,7 @@ func (s *SimTestSuite) TestSimulateMsgSupply() {
 	var msg types.MsgSupply
 	s.unmarshal(&operationMsg, &msg)
 	s.Require().Equal("umee1ghekyjucln7y67ntx7cf27m9dpuxxemn8w6h33", msg.Supplier)
-	s.Require().Equal("4896096uumee", msg.Asset.String())
+	s.Require().Equal("23872177uumee", msg.Asset.String())
 	s.Require().Len(futureOperations, 0)
 }
 

x/leverage/types/genesis.go

@@ -36,7 +36,7 @@ func NewGenesisState(
 func DefaultGenesis() *GenesisState {
 	return &GenesisState{
 		Params:           DefaultParams(),
-		Registry:         []Token{},
+		Registry:         DefaultRegistry(),
 		LastInterestTime: 0,
 	}
 }

x/leverage/types/params.go

@@ -19,11 +19,11 @@ var (
 )
 
 var (
-	defaultCompleteLiquidationThreshold = sdk.MustNewDecFromStr("0.1")
-	defaultMinimumCloseFactor           = sdk.MustNewDecFromStr("0.01")
+	defaultCompleteLiquidationThreshold = sdk.MustNewDecFromStr("0.4")
+	defaultMinimumCloseFactor           = sdk.MustNewDecFromStr("0.05")
 	defaultOracleRewardFactor           = sdk.MustNewDecFromStr("0.01")
-	defaultSmallLiquidationSize         = sdk.MustNewDecFromStr("100.00")
-	defaultDirectLiquidationFee         = sdk.MustNewDecFromStr("0.1")
+	defaultSmallLiquidationSize         = sdk.MustNewDecFromStr("500.00")
+	defaultDirectLiquidationFee         = sdk.MustNewDecFromStr("0.05")
 )
 
 func NewParams() Params {

x/leverage/types/token.go

@@ -6,6 +6,7 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	appparams "github.com/umee-network/umee/v3/app/params"
 )
 
 const (
@@ -149,3 +150,67 @@ func (t Token) AssertNotBlacklisted() error {
 	}
 	return nil
 }
+
+func defaultUmeeToken() Token {
+	return Token{
+		BaseDenom:       appparams.BondDenom,
+		SymbolDenom:     "UMEE",
+		Exponent:        6,
+		EnableMsgSupply: true,
+		EnableMsgBorrow: true,
+		Blacklist:       false,
+		// Reserves
+		ReserveFactor: sdk.MustNewDecFromStr("0.10"),
+		// Interest rate model
+		BaseBorrowRate:  sdk.MustNewDecFromStr("0.05"),
+		KinkBorrowRate:  sdk.MustNewDecFromStr("0.10"),
+		MaxBorrowRate:   sdk.MustNewDecFromStr("0.80"),
+		KinkUtilization: sdk.MustNewDecFromStr("0.50"),
+		// Collateral
+		CollateralWeight:     sdk.MustNewDecFromStr("0.35"),
+		LiquidationThreshold: sdk.MustNewDecFromStr("0.50"),
+		// Liquidation
+		LiquidationIncentive: sdk.MustNewDecFromStr("0.10"),
+		// Market limits
+		MaxCollateralShare:     sdk.MustNewDecFromStr("1.00"),
+		MaxSupplyUtilization:   sdk.MustNewDecFromStr("0.90"),
+		MinCollateralLiquidity: sdk.MustNewDecFromStr("0.3"),
+		MaxSupply:              sdk.NewInt(1000_000000_000000),
+	}
+}
+
+func defaultAtomToken() Token {
+	return Token{
+		// Denom matches mainnet (channel-1) ATOM
+		BaseDenom:       "ibc/C4CFF46FD6DE35CA4CF4CE031E643C8FDC9BA4B99AE598E9B0ED98FE3A2319F9",
+		SymbolDenom:     "ATOM",
+		Exponent:        6,
+		EnableMsgSupply: true,
+		EnableMsgBorrow: true,
+		Blacklist:       false,
+		// Reserves
+		ReserveFactor: sdk.MustNewDecFromStr("0.10"),
+		// Interest rate model
+		BaseBorrowRate:  sdk.MustNewDecFromStr("0.03"),
+		KinkBorrowRate:  sdk.MustNewDecFromStr("0.11"),
+		MaxBorrowRate:   sdk.MustNewDecFromStr("0.80"),
+		KinkUtilization: sdk.MustNewDecFromStr("0.70"),
+		// Collateral
+		CollateralWeight:     sdk.MustNewDecFromStr("0.70"),
+		LiquidationThreshold: sdk.MustNewDecFromStr("0.80"),
+		// Liquidation
+		LiquidationIncentive: sdk.MustNewDecFromStr("0.05"),
+		// Market limits
+		MaxCollateralShare:     sdk.MustNewDecFromStr("1.00"),
+		MaxSupplyUtilization:   sdk.MustNewDecFromStr("0.95"),
+		MinCollateralLiquidity: sdk.MustNewDecFromStr("0.18"),
+		MaxSupply:              sdk.NewInt(0),
+	}
+}
+
+func DefaultRegistry() []Token {
+	return []Token{
+		defaultUmeeToken(),
+		defaultAtomToken(),
+	}
+}

x/oracle/keeper/hooks_test.go

@@ -7,21 +7,21 @@ import (
 
 func (s *IntegrationTestSuite) TestHooks_AfterTokenRegistered() {
 	h := s.app.OracleKeeper.Hooks()
-	s.Require().Len(s.app.OracleKeeper.AcceptList(s.ctx), 1)
+	s.Require().Len(s.app.OracleKeeper.AcceptList(s.ctx), 2)
 
 	// require that an existing token does not change the accept list
 	h.AfterTokenRegistered(s.ctx, leveragetypes.Token{
 		BaseDenom:   appparams.BondDenom,
 		SymbolDenom: appparams.DisplayDenom,
 		Exponent:    6,
 	})
-	s.Require().Len(s.app.OracleKeeper.AcceptList(s.ctx), 1)
+	s.Require().Len(s.app.OracleKeeper.AcceptList(s.ctx), 2)
 
 	// require a new registered token updates the accept list
 	h.AfterTokenRegistered(s.ctx, leveragetypes.Token{
 		BaseDenom:   "ibc/CDC4587874B85BEA4FCEC3CEA5A1195139799A1FEE711A07D972537E18FDA39D",
 		SymbolDenom: "atom",
 		Exponent:    6,
 	})
-	s.Require().Len(s.app.OracleKeeper.AcceptList(s.ctx), 2)
+	s.Require().Len(s.app.OracleKeeper.AcceptList(s.ctx), 3)
 }

x/oracle/types/asset.go

@@ -10,6 +10,9 @@ const (
 	UmeeDenom       string = appparams.BondDenom
 	UmeeSymbol      string = "umee"
 	UmeeExponent           = uint32(6)
+	AtomDenom       string = "ibc/C4CFF46FD6DE35CA4CF4CE031E643C8FDC9BA4B99AE598E9B0ED98FE3A2319F9"
+	AtomSymbol      string = "atom"
+	AtomExponent           = uint32(6)
 	USDDenom        string = "USD"
 	BlocksPerMinute        = uint64(10)
 	BlocksPerHour          = BlocksPerMinute * 60

x/oracle/types/params.go

@@ -37,6 +37,11 @@ var (
 			SymbolDenom: UmeeSymbol,
 			Exponent:    UmeeExponent,
 		},
+		{
+			BaseDenom:   AtomDenom,
+			SymbolDenom: AtomSymbol,
+			Exponent:    AtomExponent,
+		},
 	}
 	DefaultSlashFraction     = sdk.NewDecWithPrec(1, 4) // 0.01%
 	DefaultMinValidPerWindow = sdk.NewDecWithPrec(5, 2) // 5%