diff --git a/scripts/run-node.sh b/scripts/run-node.sh index eb685ff8c..f0342382c 100755 --- a/scripts/run-node.sh +++ b/scripts/run-node.sh @@ -58,6 +58,7 @@ $BINARY gentx $KEY 10030009994127689ppica --keyring-backend $KEYRING --chain-id update_test_genesis '.app_state["gov"]["params"]["voting_period"]="20s"' update_test_genesis '.app_state["gov"]["params"]["expedited_voting_period"]="10s"' +update_test_genesis '.app_state["stakingmiddleware"]["params"]["blocks_per_epoch"]="5"' update_test_genesis '.app_state["mint"]["params"]["mint_denom"]="'$DENOM'"' update_test_genesis '.app_state["gov"]["params"]["min_deposit"]=[{"denom":"'$DENOM'","amount": "1"}]' update_test_genesis '.app_state["crisis"]["constant_fee"]={"denom":"'$DENOM'","amount":"1000"}' diff --git a/tests/interchaintest/chain_core_test.go b/tests/interchaintest/chain_core_test.go new file mode 100644 index 000000000..8efd2b47e --- /dev/null +++ b/tests/interchaintest/chain_core_test.go @@ -0,0 +1,766 @@ +package interchaintest + +import ( + "context" + "fmt" + "math" + "testing" + "time" + + sdkmath "cosmossdk.io/math" + "github.com/cosmos/cosmos-sdk/crypto/keyring" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/strangelove-ventures/interchaintest/v8/testutil" + "github.com/stretchr/testify/require" + "go.uber.org/zap/zaptest" + + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + vestingcli "github.com/cosmos/cosmos-sdk/x/auth/vesting/client/cli" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + govv1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +var ( + numValsOne = 1 + numFullNodesZero = 0 + genesisAmt = sdkmath.NewInt(10_000_000_000) + + mnemonic = "decorate bright ozone fork gallery riot bus exhaust worth way bone indoor calm squirrel merry zero scheme cotton until shop any excess stage laundry" + + denomMetadata = banktypes.Metadata{ + Description: "Denom metadata for TOK (token)", + DenomUnits: []*banktypes.DenomUnit{ + { + Denom: "stake", + Exponent: 0, + Aliases: []string{}, + }, + { + Denom: "TOK", + Exponent: 6, + Aliases: []string{}, + }, + }, + Base: "stake", + Display: "TOK", + Name: "TOK", + Symbol: "TOK", + URI: "", + URIHash: "", + } + + baseBech32 = "pica" +) + +func TestCoreSDKCommands(t *testing.T) { + if testing.Short() { + t.Skip("skipping in short mode") + } + t.Parallel() + + cosmos.SetSDKConfig(baseBech32) + + sdk47Genesis := []cosmos.GenesisKV{ + cosmos.NewGenesisKV("app_state.gov.params.voting_period", "15s"), + cosmos.NewGenesisKV("app_state.gov.params.max_deposit_period", "10s"), + cosmos.NewGenesisKV("app_state.stakingmiddleware.params.blocks_per_epoch", 5), + cosmos.NewGenesisKV("app_state.gov.params.min_deposit.0.denom", "stake"), + cosmos.NewGenesisKV("app_state.gov.params.min_deposit.0.amount", "1"), + cosmos.NewGenesisKV("app_state.bank.denom_metadata", []banktypes.Metadata{denomMetadata}), + } + + config := CentauriConfig + config.ModifyGenesis = cosmos.ModifyGenesis(sdk47Genesis) + + cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ + { + Name: "centauri", + ChainConfig: config, + NumValidators: &numVals, + NumFullNodes: &numFullNodes, + }, + }) + + chains, err := cf.Chains(t.Name()) + require.NoError(t, err) + + chain := chains[0].(*cosmos.CosmosChain) + + ic := interchaintest.NewInterchain(). + AddChain(chain) + + ctx := context.Background() + client, network := interchaintest.DockerSetup(t) + + require.NoError(t, ic.Build(ctx, nil, interchaintest.InterchainBuildOptions{ + TestName: t.Name(), + Client: client, + NetworkID: network, + SkipPathCreation: true, + })) + t.Cleanup(func() { + _ = ic.Close() + }) + + // used in circuit + superAdmin, err := interchaintest.GetAndFundTestUserWithMnemonic(ctx, "acc0", mnemonic, genesisAmt, chain) + require.NoError(t, err) + + t.Run("authz", func(t *testing.T) { + users := interchaintest.GetAndFundTestUsers(t, ctx, "default", genesisAmt, chain, chain, chain) + testAuthz(ctx, t, chain, users) + }) + + t.Run("bank", func(t *testing.T) { + users := interchaintest.GetAndFundTestUsers(t, ctx, "default", genesisAmt, chain, chain, chain) + testBank(ctx, t, chain, users) + }) + + t.Run("distribution", func(t *testing.T) { + users := interchaintest.GetAndFundTestUsers(t, ctx, "default", genesisAmt, chain, chain, chain) + testDistribution(ctx, t, chain, users) + }) + + t.Run("feegrant", func(t *testing.T) { + users := interchaintest.GetAndFundTestUsers(t, ctx, "default", genesisAmt, chain, chain, chain, chain) + testFeeGrant(ctx, t, chain, users) + }) + + t.Run("gov", func(t *testing.T) { + users := interchaintest.GetAndFundTestUsers(t, ctx, "default", genesisAmt, chain, chain, chain) + testGov(ctx, t, chain, users) + }) + + t.Run("auth-vesting", func(t *testing.T) { + testAuth(ctx, t, chain) + testVesting(ctx, t, chain, superAdmin) + }) + + t.Run("upgrade", func(t *testing.T) { + testUpgrade(ctx, t, chain) + }) + + t.Run("staking", func(t *testing.T) { + users := interchaintest.GetAndFundTestUsers(t, ctx, "default", genesisAmt, chain, chain, chain) + testStaking(ctx, t, chain, users) + }) + + t.Run("slashing", func(t *testing.T) { + testSlashing(ctx, t, chain) + }) +} + +func testAuth(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain) { + // get gov address + govAddr, err := chain.AuthQueryModuleAddress(ctx, "gov") + require.NoError(t, err) + require.NotEmpty(t, govAddr) + + // convert gov addr to bytes + govBz, err := chain.AccAddressFromBech32(govAddr) + require.NoError(t, err) + + // convert gov bytes back to string address + strAddr, err := chain.AuthAddressBytesToString(ctx, govBz) + require.NoError(t, err) + require.EqualValues(t, govAddr, strAddr) + + // convert gov string address back to bytes + bz, err := chain.AuthAddressStringToBytes(ctx, strAddr) + require.NoError(t, err) + require.EqualValues(t, govBz, bz) + + // params + p, err := chain.AuthQueryParams(ctx) + require.NoError(t, err) + require.NotNil(t, p) + require.True(t, p.MaxMemoCharacters > 0) + + // get all module accounts + accs, err := chain.AuthQueryModuleAccounts(ctx) + require.NoError(t, err) + require.NotEmpty(t, accs) + + // get the global bech32 prefix + bech32, err := chain.AuthQueryBech32Prefix(ctx) + require.NoError(t, err) + require.EqualValues(t, baseBech32, bech32) + + // get base info about an account + accInfo, err := chain.AuthQueryAccountInfo(ctx, govAddr) + require.NoError(t, err) + require.EqualValues(t, govAddr, accInfo.Address) + +} + +// testUpgrade test the queries for upgrade information. Actual upgrades take place in other test. +func testUpgrade(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain) { + v, err := chain.UpgradeQueryAllModuleVersions(ctx) + require.NoError(t, err) + require.NotEmpty(t, v) + + // UpgradeQueryModuleVersion + authority, err := chain.UpgradeQueryAuthority(ctx) + require.NoError(t, err) + require.NotEmpty(t, authority) + + plan, err := chain.UpgradeQueryPlan(ctx) + require.NoError(t, err) + require.Nil(t, plan) + + _, err = chain.UpgradeQueryAppliedPlan(ctx, "") + require.NoError(t, err) +} + +func testAuthz(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + granter := users[0].FormattedAddress() + grantee := users[1].FormattedAddress() + + node := chain.GetNode() + + txRes, _ := node.AuthzGrant(ctx, users[0], grantee, "generic", "--msg-type", "/cosmos.bank.v1beta1.MsgSend") + require.EqualValues(t, 0, txRes.Code) + + grants, err := chain.AuthzQueryGrants(ctx, granter, grantee, "") + require.NoError(t, err) + require.Len(t, grants, 1) + require.EqualValues(t, grants[0].Authorization.TypeUrl, "/cosmos.authz.v1beta1.GenericAuthorization") + require.Contains(t, string(grants[0].Authorization.Value), "/cosmos.bank.v1beta1.MsgSend") + + byGrantee, err := chain.AuthzQueryGrantsByGrantee(ctx, grantee, "") + require.NoError(t, err) + require.Len(t, byGrantee, 1) + require.EqualValues(t, byGrantee[0].Granter, granter) + require.EqualValues(t, byGrantee[0].Grantee, grantee) + + byGranter, err := chain.AuthzQueryGrantsByGranter(ctx, granter, "") + require.NoError(t, err) + require.Len(t, byGranter, 1) + require.EqualValues(t, byGranter[0].Granter, granter) + require.EqualValues(t, byGranter[0].Grantee, grantee) + + fmt.Printf("grants: %+v %+v %+v\n", grants, byGrantee, byGranter) + + balanceBefore, err := chain.GetBalance(ctx, granter, chain.Config().Denom) + require.NoError(t, err) + fmt.Printf("balanceBefore: %+v\n", balanceBefore) + + sendAmt := 1234 + + nestedCmd := []string{ + chain.Config().Bin, + "tx", "bank", "send", granter, grantee, fmt.Sprintf("%d%s", sendAmt, chain.Config().Denom), + "--from", granter, "--generate-only", + "--chain-id", chain.GetNode().Chain.Config().ChainID, + "--node", chain.GetNode().Chain.GetRPCAddress(), + "--home", chain.GetNode().HomeDir(), + "--keyring-backend", keyring.BackendTest, + "--output", "json", + "--yes", + } + + resp, err := node.AuthzExec(ctx, users[1], nestedCmd) + require.NoError(t, err) + require.EqualValues(t, 0, resp.Code) + + balanceAfter, err := chain.GetBalance(ctx, granter, chain.Config().Denom) + require.NoError(t, err) + + fmt.Printf("balanceAfter: %+v\n", balanceAfter) + require.EqualValues(t, balanceBefore.SubRaw(int64(sendAmt)), balanceAfter) +} + +func testBank(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + user0 := users[0].FormattedAddress() + user1 := users[1].FormattedAddress() + user2 := users[2].FormattedAddress() + + b2, err := chain.BankQueryBalance(ctx, user1, chain.Config().Denom) + require.NoError(t, err) + + // send 1 token + sendAmt := int64(1) + _, err = sendTokens(ctx, chain, users[0], users[1], "", sendAmt) + require.NoError(t, err) + + // send multiple + err = chain.GetNode().BankMultiSend(ctx, users[0].KeyName(), []string{user1, user2}, sdkmath.NewInt(sendAmt), chain.Config().Denom) + require.NoError(t, err) + + // == balances == + // sendAmt*2 because of the multisend as well + b2New, err := chain.GetBalance(ctx, user1, chain.Config().Denom) + require.NoError(t, err) + require.Equal(t, b2.Add(sdkmath.NewInt(sendAmt*2)), b2New) + + b2All, err := chain.BankQueryAllBalances(ctx, user1) + require.NoError(t, err) + require.Equal(t, b2New, b2All.AmountOf(chain.Config().Denom)) + + // == spendable balances == + spendableBal, err := chain.BankQuerySpendableBalance(ctx, user0, chain.Config().Denom) + require.NoError(t, err) + + spendableBals, err := chain.BankQuerySpendableBalances(ctx, user0) + require.NoError(t, err) + require.Equal(t, spendableBal.Amount, spendableBals.AmountOf(chain.Config().Denom)) + + // == metadata == + meta, err := chain.BankQueryDenomMetadata(ctx, chain.Config().Denom) + require.NoError(t, err) + + meta2, err := chain.BankQueryDenomMetadataByQueryString(ctx, chain.Config().Denom) + require.NoError(t, err) + require.EqualValues(t, meta, meta2) + + allMeta, err := chain.BankQueryDenomsMetadata(ctx) + require.NoError(t, err) + require.Len(t, allMeta, 1) + require.EqualValues(t, allMeta[0].Display, meta.Display) + + // == params == + params, err := chain.BankQueryParams(ctx) + require.NoError(t, err) + require.True(t, params.DefaultSendEnabled) + + sendEnabled, err := chain.BankQuerySendEnabled(ctx, []string{chain.Config().Denom}) + require.NoError(t, err) + require.Len(t, sendEnabled, 0) + + // == supply == + supply, err := chain.BankQueryTotalSupply(ctx) + require.NoError(t, err) + + supplyOf, err := chain.BankQueryTotalSupplyOf(ctx, chain.Config().Denom) + require.NoError(t, err) + require.True(t, supplyOf.IsGTE(sdk.NewCoin(chain.Config().Denom, supply.AmountOf(chain.Config().Denom)))) + + // == denom owner == + denomOwner, err := chain.BankQueryDenomOwners(ctx, chain.Config().Denom) + require.NoError(t, err) + + found := false + for _, owner := range denomOwner { + if owner.Address == user0 { + found = true + break + } + } + require.True(t, found) +} + +func testDistribution(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + var err error + node := chain.GetNode() + err = testutil.WaitForBlocks(ctx, 10, node) + + acc := authtypes.NewModuleAddress("distribution") + require := require.New(t) + + vals, err := chain.StakingQueryValidators(ctx, stakingtypes.Bonded.String()) + require.NoError(err) + fmt.Printf("validators: %+v\n", vals) + + del, err := chain.StakingQueryDelegationsTo(ctx, vals[0].OperatorAddress) + require.NoError(err) + + delAddr := del[0].Delegation.DelegatorAddress + valAddr := del[0].Delegation.ValidatorAddress + + newWithdrawAddr := "pica1hj83l3auyqgy5qcp52l6sp2e67xwq9xxun76km" + + t.Run("misc queries", func(t *testing.T) { + slashes, err := chain.DistributionQueryValidatorSlashes(ctx, valAddr) + require.NoError(err) + require.EqualValues(0, len(slashes)) + + valDistInfo, err := chain.DistributionQueryValidatorDistributionInfo(ctx, valAddr) + require.NoError(err) + fmt.Printf("valDistInfo: %+v\n", valDistInfo) + require.EqualValues(1, valDistInfo.Commission.Len()) + + valOutRewards, err := chain.DistributionQueryValidatorOutstandingRewards(ctx, valAddr) + require.NoError(err) + require.EqualValues(1, valOutRewards.Rewards.Len()) + + params, err := chain.DistributionQueryParams(ctx) + require.NoError(err) + require.True(params.WithdrawAddrEnabled) + + comm, err := chain.DistributionQueryCommission(ctx, valAddr) + require.NoError(err) + require.EqualValues(chain.Config().Denom, comm.Commission[0].Denom) + }) + + t.Run("withdraw-all-rewards", func(t *testing.T) { + err = node.StakingDelegate(ctx, users[2].KeyName(), valAddr, fmt.Sprintf("%d%s", uint64(100*math.Pow10(6)), chain.Config().Denom)) + require.NoError(err) + + before, err := chain.BankQueryBalance(ctx, acc.String(), chain.Config().Denom) + require.NoError(err) + fmt.Printf("before: %+v\n", before) + + err = node.DistributionWithdrawAllRewards(ctx, users[2].KeyName()) + require.NoError(err) + + after, err := chain.BankQueryBalance(ctx, acc.String(), chain.Config().Denom) + require.NoError(err) + fmt.Printf("after: %+v\n", after) + require.True(after.GT(before)) + }) + + t.Run("fund-pools", func(t *testing.T) { + bal, err := chain.BankQueryBalance(ctx, acc.String(), chain.Config().Denom) + require.NoError(err) + fmt.Printf("CP balance: %+v\n", bal) + + amount := uint64(9_000 * math.Pow10(6)) + + err = node.DistributionFundCommunityPool(ctx, users[0].KeyName(), fmt.Sprintf("%d%s", amount, chain.Config().Denom)) + require.NoError(err) + + err = node.DistributionFundValidatorRewardsPool(ctx, users[0].KeyName(), valAddr, fmt.Sprintf("%d%s", uint64(100*math.Pow10(6)), chain.Config().Denom)) + require.NoError(err) + + bal2, err := chain.BankQueryBalance(ctx, acc.String(), chain.Config().Denom) + require.NoError(err) + fmt.Printf("New CP balance: %+v\n", bal2) // 9147579661 + + require.True(bal2.Sub(bal).GT(sdkmath.NewInt(int64(amount)))) + + // queries + coins, err := chain.DistributionQueryCommunityPool(ctx) + require.NoError(err) + require.True(coins.AmountOf(chain.Config().Denom).GT(sdkmath.LegacyNewDec(int64(amount)))) + }) + + t.Run("set-custiom-withdraw-address", func(t *testing.T) { + err = node.DistributionSetWithdrawAddr(ctx, users[0].KeyName(), newWithdrawAddr) + require.NoError(err) + + withdrawAddr, err := chain.DistributionQueryDelegatorWithdrawAddress(ctx, users[0].FormattedAddress()) + require.NoError(err) + require.EqualValues(withdrawAddr, newWithdrawAddr) + }) + + t.Run("delegator", func(t *testing.T) { + delRewards, err := chain.DistributionQueryDelegationTotalRewards(ctx, delAddr) + require.NoError(err) + r := delRewards.Rewards[0] + require.EqualValues(valAddr, r.ValidatorAddress) + require.EqualValues(chain.Config().Denom, r.Reward[0].Denom) + + delegatorVals, err := chain.DistributionQueryDelegatorValidators(ctx, delAddr) + require.NoError(err) + require.EqualValues(valAddr, delegatorVals.Validators[0]) + + rewards, err := chain.DistributionQueryRewards(ctx, delAddr, valAddr) + require.NoError(err) + require.EqualValues(1, rewards.Len()) + }) +} + +func testFeeGrant(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + var err error + node := chain.GetNode() + + denom := chain.Config().Denom + + t.Run("successful grant and queries", func(t *testing.T) { + granter := users[0] + grantee := users[1] + + err = node.FeeGrant(ctx, granter.KeyName(), grantee.FormattedAddress(), fmt.Sprintf("%d%s", 1000, chain.Config().Denom), []string{"/cosmos.bank.v1beta1.MsgSend"}, time.Now().Add(time.Hour*24*365)) + require.NoError(t, err) + + g, err := chain.FeeGrantQueryAllowance(ctx, granter.FormattedAddress(), grantee.FormattedAddress()) + require.NoError(t, err) + fmt.Printf("g: %+v\n", g) + require.EqualValues(t, granter.FormattedAddress(), g.Granter) + require.EqualValues(t, grantee.FormattedAddress(), g.Grantee) + require.EqualValues(t, "/cosmos.feegrant.v1beta1.AllowedMsgAllowance", g.Allowance.TypeUrl) + require.Contains(t, string(g.Allowance.Value), "/cosmos.bank.v1beta1.MsgSend") + + all, err := chain.FeeGrantQueryAllowances(ctx, grantee.FormattedAddress()) + require.NoError(t, err) + require.Len(t, all, 1) + require.EqualValues(t, granter.FormattedAddress(), all[0].Granter) + + all2, err := chain.FeeGrantQueryAllowancesByGranter(ctx, granter.FormattedAddress()) + require.NoError(t, err) + require.Len(t, all2, 1) + require.EqualValues(t, grantee.FormattedAddress(), all2[0].Grantee) + }) + + t.Run("successful execution", func(t *testing.T) { + granter2 := users[2] + grantee2 := users[3] + + err = node.FeeGrant(ctx, granter2.KeyName(), grantee2.FormattedAddress(), fmt.Sprintf("%d%s", 100_000, denom), nil, time.Unix(0, 0)) + require.NoError(t, err) + + bal, err := chain.BankQueryBalance(ctx, granter2.FormattedAddress(), denom) + require.NoError(t, err) + + fee := 500 + sendAmt := 501 + sendCoin := fmt.Sprintf("%d%s", sendAmt, denom) + feeCoin := fmt.Sprintf("%d%s", fee, denom) + + _, err = node.ExecTx(ctx, + grantee2.KeyName(), "bank", "send", grantee2.KeyName(), granter2.FormattedAddress(), sendCoin, + "--fees", feeCoin, "--fee-granter", granter2.FormattedAddress(), + ) + require.NoError(t, err) + + newBal, err := chain.BankQueryBalance(ctx, granter2.FormattedAddress(), denom) + require.NoError(t, err) + require.EqualValues(t, bal.AddRaw(int64(sendAmt-fee)), newBal) + }) +} + +func testGov(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + node := chain.GetNode() + + govModule := "pica10d07y265gmmuvt4z0w9aw880jnsr700jp7sqj5" + coin := sdk.NewCoin(chain.Config().Denom, sdkmath.NewInt(1)) + + bankMsg := &banktypes.MsgSend{ + FromAddress: govModule, + ToAddress: users[1].FormattedAddress(), + Amount: sdk.NewCoins(coin), + } + + // submit governance proposal + title := "Test Proposal" + prop, err := chain.BuildProposal([]cosmos.ProtoMessage{bankMsg}, title, title+" Summary", "none", "500"+chain.Config().Denom, govModule, false) + require.NoError(t, err) + + _, err = node.GovSubmitProposal(ctx, users[0].KeyName(), prop) + require.NoError(t, err) + + proposal, err := chain.GovQueryProposalV1(ctx, 1) + require.NoError(t, err) + require.EqualValues(t, proposal.Title, title) + + // vote on the proposal + err = node.VoteOnProposal(ctx, users[0].KeyName(), 1, "yes") + require.NoError(t, err) + + v, err := chain.GovQueryVote(ctx, 1, users[0].FormattedAddress()) + require.NoError(t, err) + require.EqualValues(t, v.Options[0].Option, govv1.VoteOption_VOTE_OPTION_YES) + + // pass vote with all validators + err = chain.VoteOnProposalAllValidators(ctx, "1", "yes") + require.NoError(t, err) + + // GovQueryProposalsV1 + proposals, err := chain.GovQueryProposalsV1(ctx, govv1.ProposalStatus_PROPOSAL_STATUS_VOTING_PERIOD) + require.NoError(t, err) + require.Len(t, proposals, 1) + + require.NoError(t, testutil.WaitForBlocks(ctx, 10, chain)) + + // Proposal fails due to gov not having any funds + proposals, err = chain.GovQueryProposalsV1(ctx, govv1.ProposalStatus_PROPOSAL_STATUS_FAILED) + require.NoError(t, err) + require.Len(t, proposals, 1) +} + +func testSlashing(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain) { + p, err := chain.SlashingQueryParams(ctx) + require.NoError(t, err) + require.NotNil(t, p) + + infos, err := chain.SlashingQuerySigningInfos(ctx) + require.NoError(t, err) + require.NotEmpty(t, infos) + + si, err := chain.SlashingQuerySigningInfo(ctx, infos[0].Address) + require.NoError(t, err) + require.NotNil(t, si) +} + +func testStaking(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + vals, err := chain.StakingQueryValidators(ctx, stakingtypes.Bonded.String()) + require.NoError(t, err) + require.NotEmpty(t, vals) + + val := vals[0].OperatorAddress + user := users[0].FormattedAddress() + + t.Run("query validators", func(t *testing.T) { + valInfo, err := chain.StakingQueryValidator(ctx, val) + require.NoError(t, err) + require.EqualValues(t, val, valInfo.OperatorAddress) + require.EqualValues(t, stakingtypes.Bonded.String(), valInfo.Status.String()) + + del, err := chain.StakingQueryDelegationsTo(ctx, val) + require.NoError(t, err) + require.NotEmpty(t, del) + + del0 := del[0].Delegation.DelegatorAddress + + allDels, err := chain.StakingQueryDelegations(ctx, del0) + require.NoError(t, err) + require.NotEmpty(t, allDels) + + singleDel, err := chain.StakingQueryDelegation(ctx, val, del0) + require.NoError(t, err) + require.EqualValues(t, del0, singleDel.Delegation.DelegatorAddress) + + // StakingQueryDelegatorValidator + delVal, err := chain.StakingQueryDelegatorValidator(ctx, del0, val) + require.NoError(t, err) + require.True(t, delVal.OperatorAddress == val) + + delVals, err := chain.StakingQueryDelegatorValidators(ctx, del0) + require.NoError(t, err) + require.NotEmpty(t, delVals) + require.True(t, delVals[0].OperatorAddress == val) + + }) + + t.Run("misc", func(t *testing.T) { + params, err := chain.StakingQueryParams(ctx) + require.NoError(t, err) + require.EqualValues(t, "stake", params.BondDenom) + + pool, err := chain.StakingQueryPool(ctx) + require.NoError(t, err) + require.True(t, pool.BondedTokens.GT(sdkmath.NewInt(0))) + + height, err := chain.Height(ctx) + require.NoError(t, err) + + searchHeight := int64(height - 1) + + hi, err := chain.StakingQueryHistoricalInfo(ctx, searchHeight) + require.NoError(t, err) + require.EqualValues(t, searchHeight, hi.Header.Height) + }) + + t.Run("delegations", func(t *testing.T) { + node := chain.GetNode() + + err := node.StakingDelegate(ctx, users[0].KeyName(), val, "1000"+chain.Config().Denom) + require.NoError(t, err) + + dels, err := chain.StakingQueryDelegations(ctx, users[0].FormattedAddress()) + require.NoError(t, err) + found := false + for _, d := range dels { + if d.Balance.Amount.Equal(sdkmath.NewInt(1000)) { + found = true + break + } + } + require.True(t, found) + + // unbond + err = node.StakingUnbond(ctx, users[0].KeyName(), val, "25"+chain.Config().Denom) + require.NoError(t, err) + + unbonding, err := chain.StakingQueryUnbondingDelegation(ctx, user, val) + require.NoError(t, err) + require.EqualValues(t, user, unbonding.DelegatorAddress) + require.EqualValues(t, val, unbonding.ValidatorAddress) + + height := unbonding.Entries[0].CreationHeight + + unbondings, err := chain.StakingQueryUnbondingDelegations(ctx, user) + require.NoError(t, err) + require.NotEmpty(t, unbondings) + require.EqualValues(t, user, unbondings[0].DelegatorAddress) + + // StakingQueryUnbondingDelegationsFrom + unbondingsFrom, err := chain.StakingQueryUnbondingDelegationsFrom(ctx, val) + require.NoError(t, err) + require.NotEmpty(t, unbondingsFrom) + require.EqualValues(t, user, unbondingsFrom[0].DelegatorAddress) + + // StakingCancelUnbond + err = node.StakingCancelUnbond(ctx, user, val, "25"+chain.Config().Denom, height) + require.NoError(t, err) + + // ensure unbonding delegation is gone + unbondings, err = chain.StakingQueryUnbondingDelegations(ctx, user) + require.NoError(t, err) + require.Empty(t, unbondings) + }) +} + +func testVesting(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, admin ibc.Wallet) { + t.Parallel() + + var err error + var acc string + node := chain.GetNode() + + currentUnixSeconds := time.Now().Unix() + endTime := currentUnixSeconds + 60 + + t.Run("normal vesting account", func(t *testing.T) { + acc = "pica1w8arfu23uygwse72ym3krk2nhntlgdfv97pez9" + + err = node.VestingCreateAccount(ctx, admin.KeyName(), acc, "111stake", endTime) + require.NoError(t, err) + + res, err := chain.AuthQueryAccount(ctx, acc) + require.NoError(t, err) + require.EqualValues(t, "/cosmos.vesting.v1beta1.ContinuousVestingAccount", res.TypeUrl) + chain.AuthPrintAccountInfo(chain, res) + }) + + t.Run("perm locked account", func(t *testing.T) { + acc = "pica135e3r3l5333094zd37kw8s7htn7087pr8s9mj7" + + err = node.VestingCreatePermanentLockedAccount(ctx, admin.KeyName(), acc, "112stake") + require.NoError(t, err) + + res, err := chain.AuthQueryAccount(ctx, acc) + require.NoError(t, err) + require.EqualValues(t, "/cosmos.vesting.v1beta1.PermanentLockedAccount", res.TypeUrl) + chain.AuthPrintAccountInfo(chain, res) + }) + + t.Run("periodic account", func(t *testing.T) { + acc = "pica1hkar47a0ysml3fhw2jgyrnrvwq9z8tk7ead5k9" + + err = node.VestingCreatePeriodicAccount(ctx, admin.KeyName(), acc, vestingcli.VestingData{ + StartTime: currentUnixSeconds, + Periods: []vestingcli.InputPeriod{ + { + Coins: "100stake", + Length: 30, // 30 seconds + }, + { + Coins: "101stake", + Length: 30, // 30 seconds + }, + { + Coins: "102stake", + Length: 30, // 30 seconds + }, + }, + }) + require.NoError(t, err) + + res, err := chain.AuthQueryAccount(ctx, acc) + require.NoError(t, err) + require.EqualValues(t, "/cosmos.vesting.v1beta1.PeriodicVestingAccount", res.TypeUrl) + chain.AuthPrintAccountInfo(chain, res) + }) + + t.Run("Base Account", func(t *testing.T) { + res, err := chain.AuthQueryAccount(ctx, admin.FormattedAddress()) + require.NoError(t, err) + require.EqualValues(t, "/cosmos.auth.v1beta1.BaseAccount", res.TypeUrl) + chain.AuthPrintAccountInfo(chain, res) + }) +} diff --git a/tests/interchaintest/chain_miscellaneous_test.go b/tests/interchaintest/chain_miscellaneous_test.go new file mode 100644 index 000000000..9e7a7a1e9 --- /dev/null +++ b/tests/interchaintest/chain_miscellaneous_test.go @@ -0,0 +1,353 @@ +package interchaintest + +import ( + "context" + "fmt" + "testing" + + "cosmossdk.io/math" + + wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + + sdk "github.com/cosmos/cosmos-sdk/types" + testutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/strangelove-ventures/interchaintest/v8" + "github.com/strangelove-ventures/interchaintest/v8/chain/cosmos" + "github.com/strangelove-ventures/interchaintest/v8/ibc" + "github.com/stretchr/testify/require" + "go.uber.org/zap/zaptest" +) + +var ( + numVals = 1 + numFullNodes = 0 +) + +func TestICTestMiscellaneous(t *testing.T) { + if testing.Short() { + t.Skip("skipping in short mode") + } + + cosmos.SetSDKConfig("pica") + + sdk47Genesis := []cosmos.GenesisKV{ + cosmos.NewGenesisKV("app_state.gov.params.voting_period", "15s"), + cosmos.NewGenesisKV("app_state.gov.params.max_deposit_period", "10s"), + cosmos.NewGenesisKV("app_state.gov.params.min_deposit.0.denom", "ppica"), + cosmos.NewGenesisKV("app_state.gov.params.min_deposit.0.amount", "1"), + } + + config := CentauriConfig + config.ModifyGenesis = cosmos.ModifyGenesis(sdk47Genesis) + + cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{ + { + Name: "centauri", + ChainConfig: config, + NumValidators: &numVals, + NumFullNodes: &numFullNodes, + }, + }) + + chains, err := cf.Chains(t.Name()) + require.NoError(t, err) + + chain := chains[0].(*cosmos.CosmosChain) + + ic := interchaintest.NewInterchain(). + AddChain(chain) + + ctx := context.Background() + client, network := interchaintest.DockerSetup(t) + + require.NoError(t, ic.Build(ctx, nil, interchaintest.InterchainBuildOptions{ + TestName: t.Name(), + Client: client, + NetworkID: network, + SkipPathCreation: true, + })) + t.Cleanup(func() { + _ = ic.Close() + }) + + users := interchaintest.GetAndFundTestUsers(t, ctx, "default", math.NewInt(10_000_000_000), chain, chain) + + testWalletKeys(ctx, t, chain) + testSendingTokens(ctx, t, chain, users) + testFindTxs(ctx, t, chain, users) // not supported with CometMock + testPollForBalance(ctx, t, chain, users) + testRangeBlockMessages(ctx, t, chain, users) + testBroadcaster(ctx, t, chain, users) + testQueryCmd(ctx, t, chain) + testHasCommand(ctx, t, chain) + testFailedCWExecute(ctx, t, chain, users) + testAddingNode(ctx, t, chain) + testGetGovernanceAddress(ctx, t, chain) + testTXFailsOnBlockInclusion(ctx, t, chain, users) +} + +func wasmEncoding() *testutil.TestEncodingConfig { + cfg := cosmos.DefaultEncoding() + wasmtypes.RegisterInterfaces(cfg.InterfaceRegistry) + return &cfg +} + +func testFailedCWExecute(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + user := users[0] + keyName := user.KeyName() + + codeId, err := chain.StoreContract(ctx, keyName, "contracts/cw_template.wasm") + if err != nil { + t.Fatal(err) + } + + contractAddr, err := chain.InstantiateContract(ctx, keyName, codeId, `{"count":0}`, true) + if err != nil { + t.Fatal(err) + } + + // execute on the contract with the wrong message (err) + txResp, err := chain.ExecuteContract(ctx, keyName, contractAddr, `{"not_a_func":{}}`) + require.Error(t, err) + fmt.Printf("txResp.RawLog: %+v\n", txResp.RawLog) + fmt.Printf("err: %+v\n", err) + require.Contains(t, err.Error(), "failed to execute message") +} + +func testWalletKeys(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain) { + // create a general key + randKey := "randkey123" + err := chain.CreateKey(ctx, randKey) + require.NoError(t, err) + + // verify key was created properly + _, err = chain.GetAddress(ctx, randKey) + require.NoError(t, err) + + // recover a key + // juno1hj5fveer5cjtn4wd6wstzugjfdxzl0xps73ftl + keyName := "key-abc" + testMnemonic := "decorate bright ozone fork gallery riot bus exhaust worth way bone indoor calm squirrel merry zero scheme cotton until shop any excess stage laundry" + wallet, err := chain.BuildWallet(ctx, keyName, testMnemonic) + require.NoError(t, err) + + // verify + addr, err := chain.GetAddress(ctx, keyName) + require.NoError(t, err) + require.Equal(t, wallet.Address(), addr) + + tn := chain.Validators[0] + a, err := tn.KeyBech32(ctx, "key-abc", "val") + require.NoError(t, err) + require.Equal(t, a, "picavaloper1hj5fveer5cjtn4wd6wstzugjfdxzl0xpaf78xu") + + a, err = tn.KeyBech32(ctx, "key-abc", "acc") + require.NoError(t, err) + require.Equal(t, a, wallet.FormattedAddress()) + + a, err = tn.AccountKeyBech32(ctx, "key-abc") + require.NoError(t, err) + require.Equal(t, a, wallet.FormattedAddress()) +} + +func testSendingTokens(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + _, err := chain.GetBalance(ctx, users[0].FormattedAddress(), chain.Config().Denom) + require.NoError(t, err) + b2, err := chain.GetBalance(ctx, users[1].FormattedAddress(), chain.Config().Denom) + require.NoError(t, err) + + sendAmt := int64(1) + _, err = sendTokens(ctx, chain, users[0], users[1], "", sendAmt) + require.NoError(t, err) + + b2New, err := chain.GetBalance(ctx, users[1].FormattedAddress(), chain.Config().Denom) + require.NoError(t, err) + + require.Equal(t, b2.Add(math.NewInt(sendAmt)), b2New) +} + +func testFindTxs(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + height, _ := chain.Height(ctx) + + _, err := sendTokens(ctx, chain, users[0], users[1], "", 1) + require.NoError(t, err) + + txs, err := chain.FindTxs(ctx, height+1) + require.NoError(t, err) + require.NotEmpty(t, txs) + require.Equal(t, txs[0].Events[0].Type, "tx") +} + +func testPollForBalance(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + bal2, err := chain.GetBalance(ctx, users[1].FormattedAddress(), chain.Config().Denom) + require.NoError(t, err) + + amt := ibc.WalletAmount{ + Address: users[1].FormattedAddress(), + Denom: chain.Config().Denom, + Amount: math.NewInt(1), + } + + delta := int64(3) + + ch := make(chan error) + go func() { + new := amt + new.Amount = bal2.Add(math.NewInt(1)) + ch <- cosmos.PollForBalance(ctx, chain, delta, new) + }() + + err = chain.SendFunds(ctx, users[0].KeyName(), amt) + require.NoError(t, err) + require.NoError(t, <-ch) +} + +func testRangeBlockMessages(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + height, _ := chain.Height(ctx) + + _, err := sendTokens(ctx, chain, users[0], users[1], "", 1) + require.NoError(t, err) + + var bankMsgs []*banktypes.MsgSend + err = cosmos.RangeBlockMessages(ctx, chain.Config().EncodingConfig.InterfaceRegistry, chain.Validators[0].Client, height+1, func(msg sdk.Msg) bool { + found, ok := msg.(*banktypes.MsgSend) + if ok { + bankMsgs = append(bankMsgs, found) + } + return false + }) + require.NoError(t, err) +} + +func testAddingNode(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain) { + // This should be tested last or else Txs will fail on the new full node. + nodesAmt := len(chain.Nodes()) + chain.AddFullNodes(ctx, nil, 1) + require.Equal(t, nodesAmt+1, len(chain.Nodes())) +} + +func testBroadcaster(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + from := users[0].FormattedAddress() + addr1 := "pica190g5j8aszqhvtg7cprmev8xcxs6csra7tak0s2" + addr2 := "pica1a53udazy8ayufvy0s434pfwjcedzqv34dspq0f" + + c1 := sdk.NewCoins(sdk.NewCoin(chain.Config().Denom, math.NewInt(1))) + c2 := sdk.NewCoins(sdk.NewCoin(chain.Config().Denom, math.NewInt(2))) + + b := cosmos.NewBroadcaster(t, chain) + + in := banktypes.Input{ + Address: from, + Coins: c1.Add(c2[0]), + } + out := []banktypes.Output{ + { + Address: addr1, + Coins: c1, + }, + { + Address: addr2, + Coins: c2, + }, + } + + txResp, err := cosmos.BroadcastTx( + ctx, + b, + users[0], + banktypes.NewMsgMultiSend(in, out), + ) + require.NoError(t, err) + require.NotEmpty(t, txResp.TxHash) + fmt.Printf("txResp: %+v\n", txResp) + + updatedBal1, err := chain.GetBalance(ctx, addr1, chain.Config().Denom) + require.NoError(t, err) + require.Equal(t, math.NewInt(1), updatedBal1) + + updatedBal2, err := chain.GetBalance(ctx, addr2, chain.Config().Denom) + require.NoError(t, err) + require.Equal(t, math.NewInt(2), updatedBal2) + + txResp, err = cosmos.BroadcastTx( + ctx, + b, + users[0], + banktypes.NewMsgMultiSend(banktypes.Input{ + Address: addr1, + Coins: c1.Add(c2[0]), + }, out), + ) + require.Error(t, err) +} + +func testQueryCmd(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain) { + tn := chain.Validators[0] + stdout, stderr, err := tn.ExecQuery(ctx, "slashing", "params") + require.NoError(t, err) + require.NotEmpty(t, stdout) + require.Empty(t, stderr) +} + +func testHasCommand(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain) { + tn := chain.Validators[0] + res := tn.HasCommand(ctx, "query") + require.True(t, res) + + if tn.IsAboveSDK47(ctx) { + require.True(t, tn.HasCommand(ctx, "genesis")) + } else { + // 45 does not have this + require.False(t, tn.HasCommand(ctx, "genesis")) + } + + require.True(t, tn.HasCommand(ctx, "tx", "ibc")) + require.True(t, tn.HasCommand(ctx, "q", "ibc")) + require.True(t, tn.HasCommand(ctx, "keys")) + require.True(t, tn.HasCommand(ctx, "help")) + require.True(t, tn.HasCommand(ctx, "tx", "bank", "send")) + + require.False(t, tn.HasCommand(ctx, "tx", "bank", "send2notrealcmd")) + require.False(t, tn.HasCommand(ctx, "incorrectcmd")) +} + +func testGetGovernanceAddress(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain) { + govAddr, err := chain.GetGovernanceAddress(ctx) + require.NoError(t, err) + _, err = chain.AccAddressFromBech32(govAddr) + require.NoError(t, err) +} + +func testTXFailsOnBlockInclusion(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, users []ibc.Wallet) { + // this isn't a real validator, but is well formed, so it will only fail once a validator checks the staking transaction + fakeValoper, err := chain.GetNode().KeyBech32(ctx, users[0].KeyName(), "val") + require.NoError(t, err) + + txHash, err := chain.GetNode().ExecTx(ctx, users[0].FormattedAddress(), + "staking", "delegate", fakeValoper, "100"+chain.Config().Denom) + transaction, err := chain.GetTransaction(txHash) + require.NoError(t, err) + require.Equal(t, "failed to execute message; message index: 0: validator does not exist", transaction.RawLog) +} + +// helpers +func sendTokens(ctx context.Context, chain *cosmos.CosmosChain, from, to ibc.Wallet, token string, amount int64) (ibc.WalletAmount, error) { + if token == "" { + token = chain.Config().Denom + } + + sendAmt := ibc.WalletAmount{ + Address: to.FormattedAddress(), + Denom: token, + Amount: math.NewInt(amount), + } + err := chain.SendFunds(ctx, from.KeyName(), sendAmt) + return sendAmt, err +} + +func validateBalance(ctx context.Context, t *testing.T, chain *cosmos.CosmosChain, user ibc.Wallet, tfDenom string, expected int64) { + balance, err := chain.GetBalance(ctx, user.FormattedAddress(), tfDenom) + require.NoError(t, err) + require.Equal(t, balance, math.NewInt(expected)) +} diff --git a/tests/interchaintest/contracts/cw_template.wasm b/tests/interchaintest/contracts/cw_template.wasm new file mode 100644 index 000000000..909cbdd19 Binary files /dev/null and b/tests/interchaintest/contracts/cw_template.wasm differ diff --git a/x/mint/abci.go b/x/mint/abci.go index d322e6723..6fc61d605 100644 --- a/x/mint/abci.go +++ b/x/mint/abci.go @@ -1,6 +1,7 @@ package mint import ( + "context" "time" "github.com/cosmos/cosmos-sdk/telemetry" @@ -11,37 +12,40 @@ import ( ) // BeginBlocker mints new tokens for the previous block. -func BeginBlocker(ctx sdk.Context, k keeper.Keeper, ic types.InflationCalculationFn) { +func BeginBlocker(ctx context.Context, k keeper.Keeper, ic types.InflationCalculationFn) error { defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyBeginBlocker) + sdkCtx := sdk.UnwrapSDKContext(ctx) + // fetch stored minter & params - minter := k.GetMinter(ctx) - params := k.GetParams(ctx) + minter := k.GetMinter(sdkCtx) + params := k.GetParams(sdkCtx) // recalculate inflation rate - totalStakingSupply, _ := k.StakingTokenSupply(ctx) - bondedRatio, _ := k.BondedRatio(ctx) - minter.Inflation = ic(ctx, minter, params, bondedRatio, totalStakingSupply) + totalStakingSupply, _ := k.StakingTokenSupply(sdkCtx) + bondedRatio, _ := k.BondedRatio(sdkCtx) + minter.Inflation = ic(sdkCtx, minter, params, bondedRatio, totalStakingSupply) minter.AnnualProvisions = minter.NextAnnualProvisions(params, totalStakingSupply) - k.SetMinter(ctx, minter) + k.SetMinter(sdkCtx, minter) // calculate how many we would mint, but we dont mint them, we take them from the prefunded account mintedCoin := minter.BlockProvision(params) mintedCoins := sdk.NewCoins(mintedCoin) // send the minted coins to the fee collector account - err := k.AddCollectedFees(ctx, mintedCoins) + err := k.AddCollectedFees(sdkCtx, mintedCoins) if err != nil { - k.Logger(ctx).Info("Not enough incentive tokens in the mint pool to distribute") + k.Logger(sdkCtx).Info("Not enough incentive tokens in the mint pool to distribute") } if mintedCoin.Amount.IsInt64() { defer telemetry.ModuleSetGauge(types.ModuleName, float32(mintedCoin.Amount.Int64()), "minted_tokens") } - ctx.EventManager().EmitEvent( + sdkCtx.EventManager().EmitEvent( sdk.NewEvent( types.EventTypeReward, sdk.NewAttribute(sdk.AttributeKeyAmount, mintedCoin.Amount.String()), ), ) + return nil } diff --git a/x/mint/module.go b/x/mint/module.go index 194fc198c..5a2711eae 100644 --- a/x/mint/module.go +++ b/x/mint/module.go @@ -149,6 +149,11 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw // ConsensusVersion implements AppModule/ConsensusVersion. func (AppModule) ConsensusVersion() uint64 { return 1 } +// BeginBlock returns the begin blocker for the mint module. +func (am AppModule) BeginBlock(ctx context.Context) error { + return BeginBlocker(ctx, am.keeper, am.inflationCalculator) +} + // AppModuleSimulation functions // GenerateGenesisState creates a randomized GenState of the mint module. func (AppModule) GenerateGenesisState(simState *module.SimulationState) { diff --git a/x/ratelimit/keeper/abci.go b/x/ratelimit/keeper/abci.go index a3789e223..e05e79d55 100644 --- a/x/ratelimit/keeper/abci.go +++ b/x/ratelimit/keeper/abci.go @@ -1,6 +1,7 @@ package keeper import ( + "context" "fmt" "time" @@ -11,25 +12,27 @@ import ( ) // BeginBlocker of epochs module. -func (k Keeper) BeginBlocker(ctx sdk.Context) { +func (k Keeper) BeginBlocker(ctx context.Context) error { + sdkCtx := sdk.UnwrapSDKContext(ctx) + defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyBeginBlocker) - k.IterateEpochInfo(ctx, func(index int64, epochInfo types.EpochInfo) (stop bool) { - logger := k.Logger(ctx) + k.IterateEpochInfo(sdkCtx, func(index int64, epochInfo types.EpochInfo) (stop bool) { + logger := k.Logger(sdkCtx) // If blocktime < initial epoch start time, return - if ctx.BlockTime().Before(epochInfo.StartTime) { + if sdkCtx.BlockTime().Before(epochInfo.StartTime) { return true } // if epoch counting hasn't started, signal we need to start. shouldInitialEpochStart := !epochInfo.EpochCountingStarted epochEndTime := epochInfo.CurrentEpochStartTime.Add(epochInfo.Duration) - shouldEpochStart := (ctx.BlockTime().After(epochEndTime)) || shouldInitialEpochStart + shouldEpochStart := (sdkCtx.BlockTime().After(epochEndTime)) || shouldInitialEpochStart if !shouldEpochStart { return false } - epochInfo.CurrentEpochStartHeight = ctx.BlockHeight() + epochInfo.CurrentEpochStartHeight = sdkCtx.BlockHeight() if shouldInitialEpochStart { epochInfo.EpochCountingStarted = true @@ -37,22 +40,23 @@ func (k Keeper) BeginBlocker(ctx sdk.Context) { epochInfo.CurrentEpochStartTime = epochInfo.StartTime logger.Info(fmt.Sprintf("Starting new epoch with identifier %s epoch number %d", epochInfo.Identifier, epochInfo.CurrentEpoch)) } else { - k.AfterEpochEnd(ctx, epochInfo) + k.AfterEpochEnd(sdkCtx, epochInfo) epochInfo.CurrentEpoch++ epochInfo.CurrentEpochStartTime = epochInfo.CurrentEpochStartTime.Add(epochInfo.Duration) logger.Info(fmt.Sprintf("Starting epoch with identifier %s epoch number %d", epochInfo.Identifier, epochInfo.CurrentEpoch)) } // emit new epoch start event, set epoch info, and run BeforeEpochStart hook - ctx.EventManager().EmitEvent( + sdkCtx.EventManager().EmitEvent( sdk.NewEvent( types.EventTypeEpochStart, sdk.NewAttribute(types.AttributeEpochNumber, fmt.Sprintf("%d", epochInfo.CurrentEpoch)), sdk.NewAttribute(types.AttributeEpochStartTime, fmt.Sprintf("%d", epochInfo.CurrentEpochStartTime.Unix())), ), ) - k.setEpochInfo(ctx, epochInfo) + k.setEpochInfo(sdkCtx, epochInfo) return false }) + return nil } diff --git a/x/ratelimit/module.go b/x/ratelimit/module.go index c17e7b48c..9d5e140eb 100644 --- a/x/ratelimit/module.go +++ b/x/ratelimit/module.go @@ -136,7 +136,15 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw // ConsensusVersion implements AppModule/ConsensusVersion. func (AppModule) ConsensusVersion() uint64 { return 1 } -// AppModuleSimulation functions +// BeginBlock implements the AppModule interface +func (am AppModule) BeginBlock(ctx context.Context) error { + return am.keeper.BeginBlocker(ctx) +} + +// EndBlock implements the AppModule interface +func (am AppModule) EndBlock(_ context.Context) ([]abci.ValidatorUpdate, error) { + return []abci.ValidatorUpdate{}, nil +} // GenerateGenesisState creates a randomized GenState of the router module. func (AppModule) GenerateGenesisState(_ *module.SimulationState) {} diff --git a/x/stakingmiddleware/keeper/genesis.go b/x/stakingmiddleware/keeper/genesis.go index c50d10dcf..ab160a7ba 100644 --- a/x/stakingmiddleware/keeper/genesis.go +++ b/x/stakingmiddleware/keeper/genesis.go @@ -1,6 +1,7 @@ package keeper import ( + "fmt" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/notional-labs/composable/v6/x/stakingmiddleware/types" ) @@ -8,6 +9,7 @@ import ( // InitGenesis new stake middleware genesis func (keeper Keeper) InitGenesis(ctx sdk.Context, data *types.GenesisState) { if err := keeper.SetParams(ctx, data.Params); err != nil { + fmt.Println(err) panic(err) } } diff --git a/x/transfermiddleware/keeper/abci.go b/x/transfermiddleware/keeper/abci.go index a3f0479d8..ff6f24b08 100644 --- a/x/transfermiddleware/keeper/abci.go +++ b/x/transfermiddleware/keeper/abci.go @@ -1,19 +1,23 @@ package keeper import ( + "context" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/notional-labs/composable/v6/x/transfermiddleware/types" ) // BeginBlocker of epochs module. -func (k Keeper) BeginBlocker(ctx sdk.Context) { +func (k Keeper) BeginBlocker(ctx context.Context) error { + sdkCtx := sdk.UnwrapSDKContext(ctx) + // Iterate over remove list - k.IterateRemoveListInfo(ctx, func(removeList types.RemoveParachainIBCTokenInfo) (stop bool) { + k.IterateRemoveListInfo(sdkCtx, func(removeList types.RemoveParachainIBCTokenInfo) (stop bool) { // If pass the duration, remove parachain token info - if ctx.BlockTime().After(removeList.RemoveTime) { - k.RemoveParachainIBCInfo(ctx, removeList.NativeDenom) + if sdkCtx.BlockTime().After(removeList.RemoveTime) { + k.RemoveParachainIBCInfo(sdkCtx, removeList.NativeDenom) } return false }) + return nil } diff --git a/x/transfermiddleware/module.go b/x/transfermiddleware/module.go index f02a7926b..fa016eedc 100644 --- a/x/transfermiddleware/module.go +++ b/x/transfermiddleware/module.go @@ -129,7 +129,10 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw // ConsensusVersion implements AppModule/ConsensusVersion. func (AppModule) ConsensusVersion() uint64 { return 1 } -// AppModuleSimulation functions +// BeginBlock implements the AppModule interface +func (am AppModule) BeginBlock(ctx context.Context) error { + return am.keeper.BeginBlocker(ctx) +} // GenerateGenesisState creates a randomized GenState of the router module. func (AppModule) GenerateGenesisState(_ *module.SimulationState) {}