tests.go

package tests

import (
	sdk "github.com/cosmos/cosmos-sdk/types"

	appparams "github.com/tessornetwork/nebula/v3/app/params"
	"github.com/tessornetwork/nebula/v3/x/leverage/client/cli"
	"github.com/tessornetwork/nebula/v3/x/leverage/fixtures"
	"github.com/tessornetwork/nebula/v3/x/leverage/types"
)

func (s *IntegrationTestSuite) TestInvalidQueries() {
	invalidQueries := []testQuery{
		{
			"query market summary - invalid denom",
			cli.GetCmdQueryMarketSummary(),
			[]string{
				"abcd",
			},
			true,
			nil,
			nil,
		},
		{
			"query account balances - invalid address",
			cli.GetCmdQueryAccountBalances(),
			[]string{
				"xyz",
			},
			true,
			nil,
			nil,
		},
		{
			"query account summary - invalid address",
			cli.GetCmdQueryAccountSummary(),
			[]string{
				"xyz",
			},
			true,
			nil,
			nil,
		},
		{
			"query max withdraw - invalid address",
			cli.GetCmdQueryMaxWithdraw(),
			[]string{
				"xyz",
				"unebula",
			},
			true,
			nil,
			nil,
		},
	}

	// These queries do not require any borrower setup because they contain invalid arguments
	s.runTestQueries(invalidQueries...)
}

func (s *IntegrationTestSuite) TestLeverageScenario() {
	val := s.network.Validators[0]

	oracleSymbolPrice := sdk.MustNewDecFromStr("34.21")

	initialQueries := []testQuery{
		{
			"query params",
			cli.GetCmdQueryParams(),
			[]string{},
			false,
			&types.QueryParamsResponse{},
			&types.QueryParamsResponse{
				Params: types.DefaultParams(),
			},
		},
		{
			"query registered tokens",
			cli.GetCmdQueryRegisteredTokens(),
			[]string{},
			false,
			&types.QueryRegisteredTokensResponse{},
			&types.QueryRegisteredTokensResponse{
				Registry: []types.Token{
					fixtures.Token(appparams.BondDenom, appparams.DisplayDenom, 6),
				},
			},
		},
		{
			"query market summary - zero supply",
			cli.GetCmdQueryMarketSummary(),
			[]string{
				appparams.BondDenom,
			},
			false,
			&types.QueryMarketSummaryResponse{},
			&types.QueryMarketSummaryResponse{
				SymbolDenom:        "NEBULA",
				Exponent:           6,
				OraclePrice:        &oracleSymbolPrice,
				UTokenExchangeRate: sdk.OneDec(),
				// Borrow rate * (1.52 - ReserveFactor - OracleRewardFactor)
				// 1.52 * (1 - 0.2 - 0.01) = 1.2008
				Supply_APY: sdk.MustNewDecFromStr("1.2008"),
				// This is an edge case technically - when effective supply, meaning
				// module balance + total borrows, is zero, utilization (0/0) is
				// interpreted as 100% so max borrow rate (152% APY) is used.
				Borrow_APY:             sdk.MustNewDecFromStr("1.52"),
				Supplied:               sdk.ZeroInt(),
				Reserved:               sdk.ZeroInt(),
				Collateral:             sdk.ZeroInt(),
				Borrowed:               sdk.ZeroInt(),
				Liquidity:              sdk.ZeroInt(),
				MaximumBorrow:          sdk.ZeroInt(),
				MaximumCollateral:      sdk.ZeroInt(),
				MinimumLiquidity:       sdk.ZeroInt(),
				UTokenSupply:           sdk.ZeroInt(),
				AvailableBorrow:        sdk.ZeroInt(),
				AvailableWithdraw:      sdk.ZeroInt(),
				AvailableCollateralize: sdk.ZeroInt(),
			},
		},
		{
			"query bad debts",
			cli.GetCmdQueryBadDebts(),
			[]string{},
			false,
			&types.QueryBadDebtsResponse{},
			&types.QueryBadDebtsResponse{
				Targets: []types.BadDebt{},
			},
		},
		{
			"query max withdraw (zero)",
			cli.GetCmdQueryMaxWithdraw(),
			[]string{
				val.Address.String(),
				"unebula",
			},
			false,
			&types.QueryMaxWithdrawResponse{},
			&types.QueryMaxWithdrawResponse{
				Tokens:  sdk.NewCoin("unebula", sdk.ZeroInt()),
				UTokens: sdk.NewCoin("u/unebula", sdk.ZeroInt()),
			},
		},
	}

	supply := testTransaction{
		"supply",
		cli.GetCmdSupply(),
		[]string{
			"700unebula",
		},
		nil,
	}

	addCollateral := testTransaction{
		"add collateral",
		cli.GetCmdCollateralize(),
		[]string{
			"700u/unebula",
		},
		nil,
	}

	supplyCollateral := testTransaction{
		"supply collateral",
		cli.GetCmdSupplyCollateral(),
		[]string{
			"300unebula",
		},
		nil,
	}

	borrow := testTransaction{
		"borrow",
		cli.GetCmdBorrow(),
		[]string{
			"249unebula", // produces a borrowed amount of 250 due to rounding
		},
		nil,
	}

	liquidate := testTransaction{
		"liquidate",
		cli.GetCmdLiquidate(),
		[]string{
			val.Address.String(),
			"5unebula", // borrower liquidates itself, reduces borrow amount and collateral by 5
			"unebula",
		},
		nil,
	}

	repay := testTransaction{
		"repay",
		cli.GetCmdRepay(),
		[]string{
			"250unebula", // repays only the remaining borrowed balance, reduced automatically from 250
		},
		nil,
	}

	removeCollateral := testTransaction{
		"remove collateral",
		cli.GetCmdDecollateralize(),
		[]string{
			"895u/unebula", // 100 u/unebula will remain
		},
		nil,
	}

	withdraw := testTransaction{
		"withdraw",
		cli.GetCmdWithdraw(),
		[]string{
			"795u/unebula", // 200 u/unebula will remain
		},
		nil,
	}

	withdrawMax := testTransaction{
		"withdraw max",
		cli.GetCmdMaxWithdraw(),
		[]string{
			"unebula",
		},
		nil,
	}

	nonzeroQueries := []testQuery{
		{
			"query account balances",
			cli.GetCmdQueryAccountBalances(),
			[]string{
				val.Address.String(),
			},
			false,
			&types.QueryAccountBalancesResponse{},
			&types.QueryAccountBalancesResponse{
				Supplied: sdk.NewCoins(
					sdk.NewInt64Coin(appparams.BondDenom, 1000),
				),
				Collateral: sdk.NewCoins(
					sdk.NewInt64Coin(types.ToUTokenDenom(appparams.BondDenom), 1000),
				),
				Borrowed: sdk.NewCoins(
					sdk.NewInt64Coin(appparams.BondDenom, 250),
				),
			},
		},
		{
			"query account summary",
			cli.GetCmdQueryAccountSummary(),
			[]string{
				val.Address.String(),
			},
			false,
			&types.QueryAccountSummaryResponse{},
			&types.QueryAccountSummaryResponse{
				// This result is nebula's oracle exchange rate from
				// app/test_helpers.go/IntegrationTestNetworkConfig
				// times the amount of nebula, and then times params
				// (1000 / 1000000) * 34.21 = 0.03421
				SuppliedValue: sdk.MustNewDecFromStr("0.03421"),
				// (1000 / 1000000) * 34.21 = 0.03421
				CollateralValue: sdk.MustNewDecFromStr("0.03421"),
				// (250 / 1000000) * 34.21 = 0.0085525
				BorrowedValue: sdk.MustNewDecFromStr("0.0085525"),
				// (1000 / 1000000) * 34.21 * 0.25 = 0.0085525
				BorrowLimit: sdk.MustNewDecFromStr("0.0085525"),
				// (1000 / 1000000) * 0.25 * 34.21 = 0.0085525
				LiquidationThreshold: sdk.MustNewDecFromStr("0.0085525"),
			},
		},
		{
			"query max withdraw (borrow limit reached)",
			cli.GetCmdQueryMaxWithdraw(),
			[]string{
				val.Address.String(),
				"unebula",
			},
			false,
			&types.QueryMaxWithdrawResponse{},
			&types.QueryMaxWithdrawResponse{
				Tokens:  sdk.NewCoin("unebula", sdk.ZeroInt()),
				UTokens: sdk.NewCoin("u/unebula", sdk.ZeroInt()),
			},
		},
	}

	postQueries := []testQuery{
		{
			"query account balances",
			cli.GetCmdQueryAccountBalances(),
			[]string{
				val.Address.String(),
			},
			false,
			&types.QueryAccountBalancesResponse{},
			&types.QueryAccountBalancesResponse{
				Supplied: sdk.NewCoins(
					sdk.NewInt64Coin(appparams.BondDenom, 201), // slightly increased uToken exchange rate
				),
				Collateral: sdk.NewCoins(
					sdk.NewInt64Coin(types.ToUTokenDenom(appparams.BondDenom), 100),
				),
				Borrowed: sdk.NewCoins(),
			},
		},
		{
			"query max withdraw (after repay)",
			cli.GetCmdQueryMaxWithdraw(),
			[]string{
				val.Address.String(),
				"unebula",
			},
			false,
			&types.QueryMaxWithdrawResponse{},
			&types.QueryMaxWithdrawResponse{
				Tokens:  sdk.NewCoin("unebula", sdk.NewInt(201)),
				UTokens: sdk.NewCoin("u/unebula", sdk.NewInt(200)),
			},
		},
	}

	lastQueries := []testQuery{
		{
			"query account balances (empty after withdraw max)",
			cli.GetCmdQueryAccountBalances(),
			[]string{
				val.Address.String(),
			},
			false,
			&types.QueryAccountBalancesResponse{},
			&types.QueryAccountBalancesResponse{
				Supplied:   sdk.NewCoins(),
				Collateral: sdk.NewCoins(),
				Borrowed:   sdk.NewCoins(),
			},
		},

		{
			"query max withdraw (after withdraw max)",
			cli.GetCmdQueryMaxWithdraw(),
			[]string{
				val.Address.String(),
				"unebula",
			},
			false,
			&types.QueryMaxWithdrawResponse{},
			&types.QueryMaxWithdrawResponse{
				Tokens:  sdk.NewCoin("unebula", sdk.ZeroInt()),
				UTokens: sdk.NewCoin("u/unebula", sdk.ZeroInt()),
			},
		},
	}

	// These queries do not require any borrower setup
	s.runTestQueries(initialQueries...)

	// These transactions will set up nonzero leverage positions and allow nonzero query results
	s.runTestTransactions(
		supply,
		addCollateral,
		supplyCollateral,
		borrow,
	)

	// These queries run while the supplying and borrowing is active to produce nonzero output
	s.runTestQueries(nonzeroQueries...)

	// These transactions run after nonzero queries are finished
	s.runTestTransactions(
		liquidate,
		repay,
		removeCollateral,
		withdraw,
	)

	// Confirm additional transaction effects
	s.runTestQueries(postQueries...)

	// This transaction will run last
	s.runTestTransactions(
		withdrawMax,
	)

	// Confirm withdraw max transaction effects
	s.runTestQueries(lastQueries...)
}