0g-chain/x/savings/keeper/grpcquery_test.go
Draco 614d4e40fe
Update cosmos-sdk to v0.47.7 (#1811)
* Update cometbft, cosmos, ethermint, and ibc-go

* Replace github.com/tendermint/tendermint by github.com/cometbft/cometbft

* Replace github.com/tendermint/tm-db by github.com/cometbft/cometbft-db

* Replace gogo/protobuf with cosmos/gogoproto & simapp replacement

* Replace cosmos-sdk/simapp/helpers with cosmos-sdk/testutil/sims

* Remove no longer used simulations

* Replace ibchost with ibcexported
See https://github.com/cosmos/ibc-go/blob/v7.2.2/docs/migrations/v6-to-v7.md#ibc-module-constants

* Add new consensus params keeper

* Add consensus keeper to blockers

* Fix keeper and module issues in app.go

* Add IsSendEnabledCoins and update SetParams interface changes

* Fix protobuf build for cosmos 47 (#1800)

* fix cp errors by using -f; fix lint by only linting our proto dir;
and use proofs.proto directly from ics23 for ibc-go v7

* run proto-all; commit updated third party deps and swagger changes

* regenerate proto files

* use correct gocosmos build plugin for buf

* re-gen all protobuf files to update paths for new gocosmos plugin

* update protoc and buf to latest versions

* fix staking keeper issues in app.go

* update tally handler for gov changes

* chain id fix and flag fixes

* update deps for cometbft 47.7 upgrade

* remove all module legacy queriers

* update stakingKeeper to pointer

* Replace ModuleCdc from govv1beta1 to govcodec

* remove simulations

* abci.LastCommitInfo → abci.CommitInfo

* Remove unused code in keys.go

* simapp.MakeTestEncodingConfig -> moduletestutil.MakeTestEncodingConfi

* Fix chain id issues in tests

* Fix remaining unit test issues

* Update changelog for upgrade

* Fix e2e tests using updated kvtool

* Update protonet to v47 compatible genesis

* Bump cometbft-db to v0.9.1-kava.1

* Update kvtool

* Remove extra changelog

* Fix merged rocksdb issues

* go mod cleanup

* Bump cometbft-db to v9 and go to 1.21

* Bump rocksdb version to v8.10.0

* Update kvtool to latest version

* Update gin to v1.9.0

* Use ibctm.ModuleName in app_test

* Fallback to genesis chain id instead of client toml

* Remove all simulations

* Fix cdp migrations issue with v47

* Update dependencies to correct tags

---------

Co-authored-by: Nick DeLuca <nickdeluca08@gmail.com>
2024-02-06 17:54:10 -05:00

355 lines
9.9 KiB
Go

package keeper_test
import (
"testing"
"time"
"github.com/stretchr/testify/suite"
sdkmath "cosmossdk.io/math"
tmprototypes "github.com/cometbft/cometbft/proto/tendermint/types"
"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/staking"
stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/kava-labs/kava/app"
liquidtypes "github.com/kava-labs/kava/x/liquid/types"
"github.com/kava-labs/kava/x/savings/keeper"
"github.com/kava-labs/kava/x/savings/types"
)
var dep = types.NewDeposit
const (
bkava1 = "bkava-kavavaloper15gqc744d05xacn4n6w2furuads9fu4pqn6zxlu"
bkava2 = "bkava-kavavaloper15qdefkmwswysgg4qxgqpqr35k3m49pkx8yhpte"
)
type grpcQueryTestSuite struct {
suite.Suite
tApp app.TestApp
ctx sdk.Context
keeper keeper.Keeper
queryServer types.QueryServer
addrs []sdk.AccAddress
}
func (suite *grpcQueryTestSuite) SetupTest() {
suite.tApp = app.NewTestApp()
_, addrs := app.GeneratePrivKeyAddressPairs(2)
suite.addrs = addrs
suite.ctx = suite.tApp.NewContext(true, tmprototypes.Header{}).
WithBlockTime(time.Now().UTC())
suite.keeper = suite.tApp.GetSavingsKeeper()
suite.queryServer = keeper.NewQueryServerImpl(suite.keeper)
err := suite.tApp.FundModuleAccount(
suite.ctx,
types.ModuleAccountName,
cs(
c("usdx", 10000000000),
c("busd", 10000000000),
),
)
suite.Require().NoError(err)
savingsGenesis := types.GenesisState{
Params: types.NewParams([]string{"bnb", "busd", bkava1, bkava2}),
}
savingsGenState := app.GenesisState{types.ModuleName: suite.tApp.AppCodec().MustMarshalJSON(&savingsGenesis)}
suite.tApp.InitializeFromGenesisStates(
savingsGenState,
app.NewFundedGenStateWithSameCoins(
suite.tApp.AppCodec(),
cs(
c("bnb", 10000000000),
c("busd", 20000000000),
),
addrs,
),
)
}
func (suite *grpcQueryTestSuite) TestGrpcQueryParams() {
res, err := suite.queryServer.Params(sdk.WrapSDKContext(suite.ctx), &types.QueryParamsRequest{})
suite.Require().NoError(err)
var expected types.GenesisState
savingsGenesis := types.GenesisState{
Params: types.NewParams([]string{"bnb", "busd", bkava1, bkava2}),
}
savingsGenState := app.GenesisState{types.ModuleName: suite.tApp.AppCodec().MustMarshalJSON(&savingsGenesis)}
suite.tApp.AppCodec().MustUnmarshalJSON(savingsGenState[types.ModuleName], &expected)
suite.Equal(expected.Params, res.Params, "params should equal test genesis state")
}
func (suite *grpcQueryTestSuite) TestGrpcQueryDeposits() {
suite.addDeposits([]types.Deposit{
dep(suite.addrs[0], cs(c("bnb", 100000000))),
dep(suite.addrs[1], cs(c("bnb", 20000000))),
dep(suite.addrs[0], cs(c("busd", 20000000))),
dep(suite.addrs[0], cs(c("busd", 8000000))),
})
tests := []struct {
giveName string
giveRequest *types.QueryDepositsRequest
wantDepositCounts int
shouldError bool
errorSubstr string
}{
{
"empty query",
&types.QueryDepositsRequest{},
2,
false,
"",
},
{
"owner",
&types.QueryDepositsRequest{
Owner: suite.addrs[0].String(),
},
// Excludes the second address
1,
false,
"",
},
{
"invalid owner",
&types.QueryDepositsRequest{
Owner: "invalid address",
},
// No deposits
0,
true,
"decoding bech32 failed",
},
{
"owner and denom",
&types.QueryDepositsRequest{
Owner: suite.addrs[0].String(),
Denom: "bnb",
},
// Only the first one
1,
false,
"",
},
{
"owner and invalid denom empty response",
&types.QueryDepositsRequest{
Owner: suite.addrs[0].String(),
Denom: "invalid denom",
},
0,
false,
"",
},
{
"denom",
&types.QueryDepositsRequest{
Denom: "bnb",
},
2,
false,
"",
},
}
for _, tt := range tests {
suite.Run(tt.giveName, func() {
res, err := suite.queryServer.Deposits(sdk.WrapSDKContext(suite.ctx), tt.giveRequest)
if tt.shouldError {
suite.Error(err)
suite.Contains(err.Error(), tt.errorSubstr)
} else {
suite.NoError(err)
suite.Equal(tt.wantDepositCounts, len(res.Deposits))
}
})
}
}
func (suite *grpcQueryTestSuite) TestGrpcQueryTotalSupply() {
testCases := []struct {
name string
deposits types.Deposits
expectedSupply sdk.Coins
}{
{
name: "returns zeros when there's no supply",
deposits: []types.Deposit{},
expectedSupply: sdk.NewCoins(),
},
{
name: "returns supply of one denom deposited from multiple accounts",
deposits: []types.Deposit{
dep(suite.addrs[0], sdk.NewCoins(c("busd", 1e6))),
dep(suite.addrs[1], sdk.NewCoins(c("busd", 1e6))),
},
expectedSupply: sdk.NewCoins(c("busd", 2e6)),
},
{
name: "returns supply of multiple denoms deposited from single account",
deposits: []types.Deposit{
dep(suite.addrs[0], sdk.NewCoins(c("busd", 1e6), c("bnb", 1e6))),
},
expectedSupply: sdk.NewCoins(c("busd", 1e6), c("bnb", 1e6)),
},
{
name: "returns supply of multiple denoms deposited from multiple accounts",
deposits: []types.Deposit{
dep(suite.addrs[0], sdk.NewCoins(c("busd", 1e6), c("bnb", 1e6))),
dep(suite.addrs[1], sdk.NewCoins(c("busd", 1e6), c("bnb", 1e6))),
},
expectedSupply: sdk.NewCoins(c("busd", 2e6), c("bnb", 2e6)),
},
}
for _, tc := range testCases {
suite.Run(tc.name, func() {
suite.SetupTest()
// setup deposits
suite.addDeposits(tc.deposits)
res, err := suite.queryServer.TotalSupply(
sdk.WrapSDKContext(suite.ctx),
&types.QueryTotalSupplyRequest{},
)
suite.Require().NoError(err)
suite.Require().Equal(tc.expectedSupply, res.Result)
})
}
suite.Run("aggregates bkava denoms, accounting for slashing", func() {
suite.SetupTest()
address1, derivatives1, _ := suite.createAccountWithDerivatives(bkava1, sdkmath.NewInt(1e9))
address2, derivatives2, _ := suite.createAccountWithDerivatives(bkava2, sdkmath.NewInt(1e9))
// bond validators
staking.EndBlocker(suite.ctx, suite.tApp.GetStakingKeeper())
// slash val2 - its shares are now 80% as valuable!
err := suite.slashValidator(sdk.ValAddress(address2), sdk.MustNewDecFromStr("0.2"))
suite.Require().NoError(err)
suite.addDeposits(
types.Deposits{
dep(address1, cs(derivatives1)),
dep(address2, cs(derivatives2)),
},
)
expectedSupply := sdk.NewCoins(
sdk.NewCoin(
"bkava",
sdkmath.NewIntFromUint64(1e9). // derivative 1
Add(sdkmath.NewInt(1e9).MulRaw(80).QuoRaw(100))), // derivative 2: original value * 80%
)
res, err := suite.queryServer.TotalSupply(
sdk.WrapSDKContext(suite.ctx),
&types.QueryTotalSupplyRequest{},
)
suite.Require().NoError(err)
suite.Require().Equal(expectedSupply, res.Result)
})
}
func (suite *grpcQueryTestSuite) addDeposits(deposits types.Deposits) {
for _, dep := range deposits {
suite.NotPanics(func() {
err := suite.keeper.Deposit(suite.ctx, dep.Depositor, dep.Amount)
suite.Require().NoError(err)
})
}
}
// createUnbondedValidator creates an unbonded validator with the given amount of self-delegation.
func (suite *grpcQueryTestSuite) createUnbondedValidator(address sdk.ValAddress, selfDelegation sdk.Coin, minSelfDelegation sdkmath.Int) error {
msg, err := stakingtypes.NewMsgCreateValidator(
address,
ed25519.GenPrivKey().PubKey(),
selfDelegation,
stakingtypes.Description{},
stakingtypes.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()),
minSelfDelegation,
)
if err != nil {
return err
}
msgServer := stakingkeeper.NewMsgServerImpl(suite.tApp.GetStakingKeeper())
_, err = msgServer.CreateValidator(sdk.WrapSDKContext(suite.ctx), msg)
return err
}
// createAccountWithDerivatives creates an account with the given amount and denom of derivative token.
// Internally, it creates a validator account and mints derivatives from the validator's self delegation.
func (suite *grpcQueryTestSuite) createAccountWithDerivatives(denom string, amount sdkmath.Int) (sdk.AccAddress, sdk.Coin, sdk.Coins) {
bondDenom := suite.tApp.GetStakingKeeper().BondDenom(suite.ctx)
valAddress, err := liquidtypes.ParseLiquidStakingTokenDenom(denom)
suite.Require().NoError(err)
address := sdk.AccAddress(valAddress)
remainingSelfDelegation := sdkmath.NewInt(1e6)
selfDelegation := sdk.NewCoin(
bondDenom,
amount.Add(remainingSelfDelegation),
)
// create & fund account
// ak := suite.tApp.GetAccountKeeper()
// acc := ak.NewAccountWithAddress(suite.ctx, address)
// ak.SetAccount(suite.ctx, acc)
err = suite.tApp.FundAccount(suite.ctx, address, sdk.NewCoins(selfDelegation))
suite.Require().NoError(err)
err = suite.createUnbondedValidator(valAddress, selfDelegation, remainingSelfDelegation)
suite.Require().NoError(err)
toConvert := sdk.NewCoin(bondDenom, amount)
derivatives, err := suite.tApp.GetLiquidKeeper().MintDerivative(suite.ctx,
address,
valAddress,
toConvert,
)
suite.Require().NoError(err)
fullBalance := suite.tApp.GetBankKeeper().GetAllBalances(suite.ctx, address)
return address, derivatives, fullBalance
}
// slashValidator slashes the validator with the given address by the given percentage.
func (suite *grpcQueryTestSuite) slashValidator(address sdk.ValAddress, slashFraction sdk.Dec) error {
stakingKeeper := suite.tApp.GetStakingKeeper()
validator, found := stakingKeeper.GetValidator(suite.ctx, address)
suite.Require().True(found)
consAddr, err := validator.GetConsAddr()
suite.Require().NoError(err)
// Assume infraction was at current height. Note unbonding delegations and redelegations are only slashed if created after
// the infraction height so none will be slashed.
infractionHeight := suite.ctx.BlockHeight()
power := stakingKeeper.TokensToConsensusPower(suite.ctx, validator.GetTokens())
stakingKeeper.Slash(suite.ctx, consAddr, infractionHeight, power, slashFraction)
return nil
}
func TestGrpcQueryTestSuite(t *testing.T) {
suite.Run(t, new(grpcQueryTestSuite))
}