test: migrate remaining e2e tests to integration tests (#22364)

Co-authored-by: Julien Robert <julien@rbrt.fr>
Co-authored-by: Marko <marko@baricevic.me>

tests/integration/accounts/base_account_test.go

@@ -0,0 +1,97 @@
+//go:build app_v1
+
+package accounts
+
+import (
+	"math/rand"
+	"testing"
+
+	gogoproto "github.com/cosmos/gogoproto/proto"
+	gogoany "github.com/cosmos/gogoproto/types/any"
+
+	"cosmossdk.io/simapp"
+	baseaccountv1 "cosmossdk.io/x/accounts/defaults/base/v1"
+	"cosmossdk.io/x/bank/testutil"
+	banktypes "cosmossdk.io/x/bank/types"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	"github.com/cosmos/cosmos-sdk/testutil/sims"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBaseAccount(t *testing.T) {
+	app := setupApp(t)
+	ak := app.AccountsKeeper
+	ctx := sdk.NewContext(app.CommitMultiStore(), false, app.Logger())
+
+	_, baseAccountAddr, err := ak.Init(ctx, "base", accCreator, &baseaccountv1.MsgInit{
+		PubKey: toAnyPb(t, privKey.PubKey()),
+	}, nil)
+	require.NoError(t, err)
+
+	// fund base account! this will also cause an auth base account to be created
+	// by the bank module.
+	// TODO: fixed by letting x/auth rely on x/accounts for acc existence checks.
+	fundAccount(t, app, ctx, baseAccountAddr, "1000000stake")
+
+	// now we make the account send a tx, public key not present.
+	// so we know it will default to x/accounts calling.
+	msg := &banktypes.MsgSend{
+		FromAddress: bechify(t, app, baseAccountAddr),
+		ToAddress:   bechify(t, app, []byte("random-addr")),
+		Amount:      coins(t, "100stake"),
+	}
+	sendTx(t, ctx, app, baseAccountAddr, msg)
+}
+
+func sendTx(t *testing.T, ctx sdk.Context, app *simapp.SimApp, sender []byte, msg sdk.Msg) {
+	tx := sign(t, ctx, app, sender, privKey, msg)
+	_, _, err := app.SimDeliver(app.TxEncode, tx)
+	require.NoError(t, err)
+}
+
+func sign(t *testing.T, ctx sdk.Context, app *simapp.SimApp, from sdk.AccAddress, privKey cryptotypes.PrivKey, msg sdk.Msg) sdk.Tx {
+	r := rand.New(rand.NewSource(0))
+
+	accNum, err := app.AccountsKeeper.AccountByNumber.Get(ctx, from)
+	require.NoError(t, err)
+	accSeq, err := app.AccountsKeeper.Query(ctx, from, &baseaccountv1.QuerySequence{})
+	require.NoError(t, err)
+
+	tx, err := sims.GenSignedMockTx(
+		r,
+		app.TxConfig(),
+		[]sdk.Msg{msg},
+		coins(t, "100stake"),
+		1_000_000,
+		app.ChainID(),
+		[]uint64{accNum},
+		[]uint64{accSeq.(*baseaccountv1.QuerySequenceResponse).Sequence},
+		privKey,
+	)
+
+	require.NoError(t, err)
+	return tx
+}
+
+func bechify(t *testing.T, app *simapp.SimApp, addr []byte) string {
+	bech32, err := app.AuthKeeper.AddressCodec().BytesToString(addr)
+	require.NoError(t, err)
+	return bech32
+}
+
+func fundAccount(t *testing.T, app *simapp.SimApp, ctx sdk.Context, addr sdk.AccAddress, amt string) {
+	require.NoError(t, testutil.FundAccount(ctx, app.BankKeeper, addr, coins(t, amt)))
+}
+
+func toAnyPb(t *testing.T, pm gogoproto.Message) *codectypes.Any {
+	t.Helper()
+	if gogoproto.MessageName(pm) == gogoproto.MessageName(&gogoany.Any{}) {
+		t.Fatal("no")
+	}
+	pb, err := codectypes.NewAnyWithValue(pm)
+	require.NoError(t, err)
+	return pb
+}

tests/integration/accounts/lockup/continous_lockup_test_suite.go

@@ -0,0 +1,203 @@
+package lockup
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"cosmossdk.io/collections"
+	"cosmossdk.io/core/header"
+	"cosmossdk.io/math"
+	lockupaccount "cosmossdk.io/x/accounts/defaults/lockup"
+	types "cosmossdk.io/x/accounts/defaults/lockup/v1"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func (s *IntegrationTestSuite) TestContinuousLockingAccount() {
+	t := s.T()
+	app := setupApp(t)
+	currentTime := time.Now()
+	ctx := sdk.NewContext(app.CommitMultiStore(), false, app.Logger()).WithHeaderInfo(header.Info{
+		Time: currentTime,
+	})
+	ownerAddrStr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
+	require.NoError(t, err)
+	s.fundAccount(app, ctx, accOwner, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000000))})
+	randAcc := sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
+	withdrawAcc := sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
+
+	_, accountAddr, err := app.AccountsKeeper.Init(ctx, lockupaccount.CONTINUOUS_LOCKING_ACCOUNT, accOwner, &types.MsgInitLockupAccount{
+		Owner:     ownerAddrStr,
+		StartTime: currentTime,
+		// end time in 1 minutes
+		EndTime: currentTime.Add(time.Minute),
+	}, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000))})
+	require.NoError(t, err)
+
+	addr, err := app.AuthKeeper.AddressCodec().BytesToString(randAcc)
+	require.NoError(t, err)
+
+	vals, err := app.StakingKeeper.GetAllValidators(ctx)
+	require.NoError(t, err)
+	val := vals[0]
+
+	t.Run("error - execute message, wrong sender", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    addr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+	t.Run("error - execute send message, insufficient fund", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    ownerAddrStr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+	t.Run("error - execute withdraw message, no withdrawable token", func(t *testing.T) {
+		ownerAddr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
+		require.NoError(t, err)
+		withdrawAddr, err := app.AuthKeeper.AddressCodec().BytesToString(withdrawAcc)
+		require.NoError(t, err)
+		msg := &types.MsgWithdraw{
+			Withdrawer: ownerAddr,
+			ToAddress:  withdrawAddr,
+			Denoms:     []string{"stake"},
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+
+	// Update context time
+	// 12 sec = 1/5 of a minute so 200stake should be released
+	ctx = ctx.WithHeaderInfo(header.Info{
+		Time: currentTime.Add(time.Second * 12),
+	})
+
+	// Check if token is sendable
+	t.Run("ok - execute send message", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    ownerAddrStr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		balance := app.BankKeeper.GetBalance(ctx, randAcc, "stake")
+		require.True(t, balance.Amount.Equal(math.NewInt(100)))
+	})
+	t.Run("ok - execute withdraw message", func(t *testing.T) {
+		ownerAddr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
+		require.NoError(t, err)
+		withdrawAddr, err := app.AuthKeeper.AddressCodec().BytesToString(withdrawAcc)
+		require.NoError(t, err)
+		msg := &types.MsgWithdraw{
+			Withdrawer: ownerAddr,
+			ToAddress:  withdrawAddr,
+			Denoms:     []string{"stake"},
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		// withdrawable amount should be 200 - 100 = 100stake
+		balance := app.BankKeeper.GetBalance(ctx, withdrawAcc, "stake")
+		require.True(t, balance.Amount.Equal(math.NewInt(100)))
+	})
+	t.Run("ok - execute delegate message", func(t *testing.T) {
+		msg := &types.MsgDelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(100)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		del, err := app.StakingKeeper.Delegations.Get(
+			ctx, collections.Join(sdk.AccAddress(accountAddr), sdk.ValAddress(valbz)),
+		)
+		require.NoError(t, err)
+		require.NotNil(t, del)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.NewInt(100)))
+	})
+	t.Run("ok - execute withdraw reward message", func(t *testing.T) {
+		msg := &types.MsgWithdrawReward{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+	})
+	t.Run("ok - execute undelegate message", func(t *testing.T) {
+		vals, err := app.StakingKeeper.GetAllValidators(ctx)
+		require.NoError(t, err)
+		val := vals[0]
+		msg := &types.MsgUndelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(100)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		ubd, err := app.StakingKeeper.GetUnbondingDelegation(
+			ctx, sdk.AccAddress(accountAddr), sdk.ValAddress(valbz),
+		)
+		require.NoError(t, err)
+		require.Equal(t, len(ubd.Entries), 1)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
+	})
+
+	// Update context time to end time
+	ctx = ctx.WithHeaderInfo(header.Info{
+		Time: currentTime.Add(time.Minute),
+	})
+
+	// test if tracking delegate work perfectly
+	t.Run("ok - execute delegate message", func(t *testing.T) {
+		msg := &types.MsgDelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(100)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		del, err := app.StakingKeeper.Delegations.Get(
+			ctx, collections.Join(sdk.AccAddress(accountAddr), sdk.ValAddress(valbz)),
+		)
+		require.NoError(t, err)
+		require.NotNil(t, del)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
+		delFree := lockupAccountInfoResponse.DelegatedFree
+		require.True(t, delFree.AmountOf("stake").Equal(math.NewInt(100)))
+	})
+}

tests/integration/accounts/lockup/delayed_lockup_test_suite.go

@@ -0,0 +1,172 @@
+package lockup
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"cosmossdk.io/collections"
+	"cosmossdk.io/core/header"
+	"cosmossdk.io/math"
+	lockupaccount "cosmossdk.io/x/accounts/defaults/lockup"
+	types "cosmossdk.io/x/accounts/defaults/lockup/v1"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func (s *IntegrationTestSuite) TestDelayedLockingAccount() {
+	t := s.T()
+	app := setupApp(t)
+	currentTime := time.Now()
+	ctx := sdk.NewContext(app.CommitMultiStore(), false, app.Logger()).WithHeaderInfo(header.Info{
+		Time: currentTime,
+	})
+	ownerAddrStr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
+	require.NoError(t, err)
+	s.fundAccount(app, ctx, accOwner, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000000))})
+	randAcc := sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
+	withdrawAcc := sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
+
+	_, accountAddr, err := app.AccountsKeeper.Init(ctx, lockupaccount.DELAYED_LOCKING_ACCOUNT, accOwner, &types.MsgInitLockupAccount{
+		Owner: ownerAddrStr,
+		// end time in 1 minutes
+		EndTime: currentTime.Add(time.Minute),
+	}, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000))})
+	require.NoError(t, err)
+
+	addr, err := app.AuthKeeper.AddressCodec().BytesToString(randAcc)
+	require.NoError(t, err)
+
+	vals, err := app.StakingKeeper.GetAllValidators(ctx)
+	require.NoError(t, err)
+	val := vals[0]
+
+	t.Run("error - execute message, wrong sender", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    addr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+	t.Run("error - execute send message, insufficient fund", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    ownerAddrStr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+	t.Run("error - execute withdraw message, no withdrawable token", func(t *testing.T) {
+		ownerAddr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
+		require.NoError(t, err)
+		withdrawAddr, err := app.AuthKeeper.AddressCodec().BytesToString(withdrawAcc)
+		require.NoError(t, err)
+		msg := &types.MsgWithdraw{
+			Withdrawer: ownerAddr,
+			ToAddress:  withdrawAddr,
+			Denoms:     []string{"stake"},
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+	t.Run("ok - execute delegate message", func(t *testing.T) {
+		msg := &types.MsgDelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(100)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		del, err := app.StakingKeeper.Delegations.Get(
+			ctx, collections.Join(sdk.AccAddress(accountAddr), sdk.ValAddress(valbz)),
+		)
+		require.NoError(t, err)
+		require.NotNil(t, del)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.NewInt(100)))
+	})
+	t.Run("ok - execute withdraw reward message", func(t *testing.T) {
+		msg := &types.MsgWithdrawReward{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+	})
+	t.Run("ok - execute undelegate message", func(t *testing.T) {
+		vals, err := app.StakingKeeper.GetAllValidators(ctx)
+		require.NoError(t, err)
+		val := vals[0]
+		msg := &types.MsgUndelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(100)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		ubd, err := app.StakingKeeper.GetUnbondingDelegation(
+			ctx, sdk.AccAddress(accountAddr), sdk.ValAddress(valbz),
+		)
+		require.NoError(t, err)
+		require.Equal(t, len(ubd.Entries), 1)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
+	})
+
+	// Update context time
+	// After endtime fund should be unlock
+	ctx = ctx.WithHeaderInfo(header.Info{
+		Time: currentTime.Add(time.Second * 61),
+	})
+
+	// Check if token is sendable after unlock
+	t.Run("ok - execute send message", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    ownerAddrStr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		balance := app.BankKeeper.GetBalance(ctx, randAcc, "stake")
+		require.True(t, balance.Amount.Equal(math.NewInt(100)))
+	})
+	// Test to withdraw all the remain funds to an account of choice
+	t.Run("ok - execute withdraw message", func(t *testing.T) {
+		ownerAddr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
+		require.NoError(t, err)
+		withdrawAddr, err := app.AuthKeeper.AddressCodec().BytesToString(withdrawAcc)
+		require.NoError(t, err)
+		msg := &types.MsgWithdraw{
+			Withdrawer: ownerAddr,
+			ToAddress:  withdrawAddr,
+			Denoms:     []string{"stake"},
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		// withdrawable amount should be
+		// 1000stake - 100stake( above sent amt ) - 100stake(above delegate amt) = 800stake
+		balance := app.BankKeeper.GetBalance(ctx, withdrawAcc, "stake")
+		require.True(t, balance.Amount.Equal(math.NewInt(800)))
+	})
+}

tests/integration/accounts/lockup/lockup_account_test.go

@@ -0,0 +1,11 @@
+package lockup
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/suite"
+)
+
+func TestIntegrationTestSuite(t *testing.T) {
+	suite.Run(t, NewIntegrationTestSuite())
+}

tests/integration/accounts/lockup/periodic_lockup_test_suite.go

@@ -0,0 +1,223 @@
+package lockup
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"cosmossdk.io/collections"
+	"cosmossdk.io/core/header"
+	"cosmossdk.io/math"
+	lockupaccount "cosmossdk.io/x/accounts/defaults/lockup"
+	types "cosmossdk.io/x/accounts/defaults/lockup/v1"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func (s *IntegrationTestSuite) TestPeriodicLockingAccount() {
+	t := s.T()
+	app := setupApp(t)
+	currentTime := time.Now()
+	ctx := sdk.NewContext(app.CommitMultiStore(), false, app.Logger()).WithHeaderInfo(header.Info{
+		Time: currentTime,
+	})
+	ownerAddrStr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
+	require.NoError(t, err)
+	s.fundAccount(app, ctx, accOwner, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000000))})
+	randAcc := sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
+	withdrawAcc := sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
+
+	_, accountAddr, err := app.AccountsKeeper.Init(ctx, lockupaccount.PERIODIC_LOCKING_ACCOUNT, accOwner, &types.MsgInitPeriodicLockingAccount{
+		Owner:     ownerAddrStr,
+		StartTime: currentTime,
+		LockingPeriods: []types.Period{
+			{
+				Amount: sdk.NewCoins(sdk.NewCoin("stake", math.NewInt(500))),
+				Length: time.Minute,
+			},
+			{
+				Amount: sdk.NewCoins(sdk.NewCoin("stake", math.NewInt(500))),
+				Length: time.Minute,
+			},
+			{
+				Amount: sdk.NewCoins(sdk.NewCoin("stake", math.NewInt(500))),
+				Length: time.Minute,
+			},
+		},
+	}, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1500))})
+	require.NoError(t, err)
+
+	addr, err := app.AuthKeeper.AddressCodec().BytesToString(randAcc)
+	require.NoError(t, err)
+
+	vals, err := app.StakingKeeper.GetAllValidators(ctx)
+	require.NoError(t, err)
+	val := vals[0]
+
+	t.Run("error - execute message, wrong sender", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    addr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+	// No token being unlocked yet
+	t.Run("error - execute send message, insufficient fund", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    ownerAddrStr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+	t.Run("error - execute withdraw message, no withdrawable token", func(t *testing.T) {
+		ownerAddr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
+		require.NoError(t, err)
+		withdrawAddr, err := app.AuthKeeper.AddressCodec().BytesToString(withdrawAcc)
+		require.NoError(t, err)
+		msg := &types.MsgWithdraw{
+			Withdrawer: ownerAddr,
+			ToAddress:  withdrawAddr,
+			Denoms:     []string{"stake"},
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+
+	// Update context time
+	// After first period 500stake should be unlock
+	ctx = ctx.WithHeaderInfo(header.Info{
+		Time: currentTime.Add(time.Minute),
+	})
+
+	// Check if 500 stake is sendable now
+	t.Run("ok - execute send message", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    ownerAddrStr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(500))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		balance := app.BankKeeper.GetBalance(ctx, randAcc, "stake")
+		require.True(t, balance.Amount.Equal(math.NewInt(500)))
+	})
+
+	// Update context time
+	// After second period 1000stake should be unlock
+	ctx = ctx.WithHeaderInfo(header.Info{
+		Time: currentTime.Add(time.Minute * 2),
+	})
+
+	t.Run("oke - execute withdraw message", func(t *testing.T) {
+		ownerAddr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
+		require.NoError(t, err)
+		withdrawAddr, err := app.AuthKeeper.AddressCodec().BytesToString(withdrawAcc)
+		require.NoError(t, err)
+		msg := &types.MsgWithdraw{
+			Withdrawer: ownerAddr,
+			ToAddress:  withdrawAddr,
+			Denoms:     []string{"stake"},
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		// withdrawable amount should be
+		// 1000stake - 500stake( above sent amt ) = 500stake
+		balance := app.BankKeeper.GetBalance(ctx, withdrawAcc, "stake")
+		require.True(t, balance.Amount.Equal(math.NewInt(500)))
+	})
+
+	t.Run("ok - execute delegate message", func(t *testing.T) {
+		msg := &types.MsgDelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(100)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		del, err := app.StakingKeeper.Delegations.Get(
+			ctx, collections.Join(sdk.AccAddress(accountAddr), sdk.ValAddress(valbz)),
+		)
+		require.NoError(t, err)
+		require.NotNil(t, del)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.NewInt(100)))
+	})
+	t.Run("ok - execute withdraw reward message", func(t *testing.T) {
+		msg := &types.MsgWithdrawReward{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+	})
+	t.Run("ok - execute undelegate message", func(t *testing.T) {
+		vals, err := app.StakingKeeper.GetAllValidators(ctx)
+		require.NoError(t, err)
+		val := vals[0]
+		msg := &types.MsgUndelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(100)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		ubd, err := app.StakingKeeper.GetUnbondingDelegation(
+			ctx, sdk.AccAddress(accountAddr), sdk.ValAddress(valbz),
+		)
+		require.NoError(t, err)
+		require.Equal(t, len(ubd.Entries), 1)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
+	})
+
+	// Update context time
+	// After third period 1500stake should be unlock
+	ctx = ctx.WithHeaderInfo(header.Info{
+		Time: currentTime.Add(time.Minute * 3),
+	})
+
+	t.Run("ok - execute delegate message", func(t *testing.T) {
+		msg := &types.MsgDelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(100)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		del, err := app.StakingKeeper.Delegations.Get(
+			ctx, collections.Join(sdk.AccAddress(accountAddr), sdk.ValAddress(valbz)),
+		)
+		require.NoError(t, err)
+		require.NotNil(t, del)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delFree := lockupAccountInfoResponse.DelegatedFree
+		require.True(t, delFree.AmountOf("stake").Equal(math.NewInt(100)))
+	})
+}

tests/integration/accounts/lockup/permanent_lockup_test_suite.go

@@ -0,0 +1,132 @@
+package lockup
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"cosmossdk.io/collections"
+	"cosmossdk.io/core/header"
+	"cosmossdk.io/math"
+	lockupaccount "cosmossdk.io/x/accounts/defaults/lockup"
+	types "cosmossdk.io/x/accounts/defaults/lockup/v1"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func (s *IntegrationTestSuite) TestPermanentLockingAccount() {
+	t := s.T()
+	app := setupApp(t)
+	currentTime := time.Now()
+	ctx := sdk.NewContext(app.CommitMultiStore(), false, app.Logger()).WithHeaderInfo(header.Info{
+		Time: currentTime,
+	})
+	ownerAddrStr, err := app.AuthKeeper.AddressCodec().BytesToString(accOwner)
+	require.NoError(t, err)
+	s.fundAccount(app, ctx, accOwner, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000000))})
+	randAcc := sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
+
+	_, accountAddr, err := app.AccountsKeeper.Init(ctx, lockupaccount.PERMANENT_LOCKING_ACCOUNT, accOwner, &types.MsgInitLockupAccount{
+		Owner: ownerAddrStr,
+	}, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000))})
+	require.NoError(t, err)
+
+	addr, err := app.AuthKeeper.AddressCodec().BytesToString(randAcc)
+	require.NoError(t, err)
+
+	vals, err := app.StakingKeeper.GetAllValidators(ctx)
+	require.NoError(t, err)
+	val := vals[0]
+
+	t.Run("error - execute message, wrong sender", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    addr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+	t.Run("error - execute send message, insufficient fund", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    ownerAddrStr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NotNil(t, err)
+	})
+	t.Run("ok - execute delegate message", func(t *testing.T) {
+		msg := &types.MsgDelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(100)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		del, err := app.StakingKeeper.Delegations.Get(
+			ctx, collections.Join(sdk.AccAddress(accountAddr), sdk.ValAddress(valbz)),
+		)
+		require.NoError(t, err)
+		require.NotNil(t, del)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.NewInt(100)))
+	})
+	t.Run("ok - execute withdraw reward message", func(t *testing.T) {
+		msg := &types.MsgWithdrawReward{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+	})
+	t.Run("ok - execute undelegate message", func(t *testing.T) {
+		vals, err := app.StakingKeeper.GetAllValidators(ctx)
+		require.NoError(t, err)
+		val := vals[0]
+		msg := &types.MsgUndelegate{
+			Sender:           ownerAddrStr,
+			ValidatorAddress: val.OperatorAddress,
+			Amount:           sdk.NewCoin("stake", math.NewInt(100)),
+		}
+		err = s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+		valbz, err := app.StakingKeeper.ValidatorAddressCodec().StringToBytes(val.OperatorAddress)
+		require.NoError(t, err)
+
+		ubd, err := app.StakingKeeper.GetUnbondingDelegation(
+			ctx, sdk.AccAddress(accountAddr), sdk.ValAddress(valbz),
+		)
+		require.NoError(t, err)
+		require.Equal(t, len(ubd.Entries), 1)
+
+		// check if tracking is updated accordingly
+		lockupAccountInfoResponse := s.queryLockupAccInfo(ctx, app, accountAddr)
+		delLocking := lockupAccountInfoResponse.DelegatedLocking
+		require.True(t, delLocking.AmountOf("stake").Equal(math.ZeroInt()))
+	})
+
+	s.fundAccount(app, ctx, accountAddr, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000))})
+
+	t.Run("ok - execute send message", func(t *testing.T) {
+		msg := &types.MsgSend{
+			Sender:    ownerAddrStr,
+			ToAddress: addr,
+			Amount:    sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))},
+		}
+		err := s.executeTx(ctx, msg, app, accountAddr, accOwner)
+		require.NoError(t, err)
+
+		balance := app.BankKeeper.GetBalance(ctx, randAcc, "stake")
+		require.True(t, balance.Amount.Equal(math.NewInt(100)))
+	})
+}

tests/integration/accounts/lockup/utils.go

@@ -0,0 +1,72 @@
+package lockup
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+
+	"cosmossdk.io/core/transaction"
+	"cosmossdk.io/simapp"
+	types "cosmossdk.io/x/accounts/defaults/lockup/v1"
+	"cosmossdk.io/x/bank/testutil"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+var (
+	ownerAddr = secp256k1.GenPrivKey().PubKey().Address()
+	accOwner  = sdk.AccAddress(ownerAddr)
+)
+
+type IntegrationTestSuite struct {
+	suite.Suite
+
+	app *simapp.SimApp
+}
+
+func NewIntegrationTestSuite() *IntegrationTestSuite {
+	return &IntegrationTestSuite{}
+}
+
+func (s *IntegrationTestSuite) SetupSuite() {
+	s.T().Log("setting up integration test suite")
+	s.app = setupApp(s.T())
+}
+
+func (s *IntegrationTestSuite) TearDownSuite() {
+	s.T().Log("tearing down integration test suite")
+}
+
+func setupApp(t *testing.T) *simapp.SimApp {
+	t.Helper()
+	app := simapp.Setup(t, false)
+	return app
+}
+
+func (s *IntegrationTestSuite) executeTx(ctx sdk.Context, msg sdk.Msg, app *simapp.SimApp, accAddr, sender []byte) error {
+	_, err := app.AccountsKeeper.Execute(ctx, accAddr, sender, msg, nil)
+	return err
+}
+
+func (s *IntegrationTestSuite) queryAcc(ctx sdk.Context, req sdk.Msg, app *simapp.SimApp, accAddr []byte) (transaction.Msg, error) {
+	resp, err := app.AccountsKeeper.Query(ctx, accAddr, req)
+	return resp, err
+}
+
+func (s *IntegrationTestSuite) fundAccount(app *simapp.SimApp, ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) {
+	require.NoError(s.T(), testutil.FundAccount(ctx, app.BankKeeper, addr, amt))
+}
+
+func (s *IntegrationTestSuite) queryLockupAccInfo(ctx sdk.Context, app *simapp.SimApp, accAddr []byte) *types.QueryLockupAccountInfoResponse {
+	req := &types.QueryLockupAccountInfoRequest{}
+	resp, err := s.queryAcc(ctx, req, app, accAddr)
+	require.NoError(s.T(), err)
+	require.NotNil(s.T(), resp)
+
+	lockupAccountInfoResponse, ok := resp.(*types.QueryLockupAccountInfoResponse)
+	require.True(s.T(), ok)
+
+	return lockupAccountInfoResponse
+}

tests/integration/accounts/multisig/account_test.go

@@ -0,0 +1,265 @@
+package multisig
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/suite"
+
+	bankv1beta1 "cosmossdk.io/api/cosmos/bank/v1beta1"
+	basev1beta1 "cosmossdk.io/api/cosmos/base/v1beta1"
+	"cosmossdk.io/core/header"
+	"cosmossdk.io/math"
+	v1 "cosmossdk.io/x/accounts/defaults/multisig/v1"
+	accountsv1 "cosmossdk.io/x/accounts/v1"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func TestIntegrationTestSuite(t *testing.T) {
+	suite.Run(t, NewIntegrationTestSuite())
+}
+
+// TestSimpleSendProposal creates a multisig account with 1 member, sends a tx, votes and executes it.
+func (s *IntegrationTestSuite) TestSimpleSendProposal() {
+	ctx := sdk.NewContext(s.app.CommitMultiStore(), false, s.app.Logger()).WithHeaderInfo(header.Info{
+		Time: time.Now(),
+	})
+
+	randAcc := sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
+	addr, err := s.app.AuthKeeper.AddressCodec().BytesToString(randAcc)
+	s.NoError(err)
+
+	initialMembers := map[string]uint64{
+		s.membersAddr[0]: 100,
+	}
+	accountAddr, accAddrStr := s.initAccount(ctx, s.members[0], initialMembers)
+
+	balance := s.app.BankKeeper.GetBalance(ctx, randAcc, "stake")
+	s.Equal(math.NewInt(0), balance.Amount)
+
+	// do a simple bank send
+	msg := &bankv1beta1.MsgSend{
+		FromAddress: accAddrStr,
+		ToAddress:   addr,
+		Amount: []*basev1beta1.Coin{
+			{
+				Denom:  "stake",
+				Amount: "100",
+			},
+		},
+	}
+	anyMsg, err := codectypes.NewAnyWithValue(msg)
+	s.NoError(err)
+
+	s.createProposal(ctx, accountAddr, s.members[0], anyMsg)
+
+	// now we vote for it
+	voteReq := &v1.MsgVote{
+		ProposalId: 0,
+		Vote:       v1.VoteOption_VOTE_OPTION_YES,
+	}
+
+	err = s.executeTx(ctx, voteReq, accountAddr, s.members[0])
+	s.NoError(err)
+
+	// now we execute it
+	err = s.executeProposal(ctx, accountAddr, s.members[0], 0)
+	s.NoError(err)
+
+	foundPropResult := false
+	for _, v := range ctx.EventManager().Events() {
+		if v.Type == "proposal_tally" {
+			foundPropResult = true
+			status, found := v.GetAttribute("status")
+			s.True(found)
+			s.Equal(v1.ProposalStatus_PROPOSAL_STATUS_PASSED.String(), status.Value)
+
+			yesVotes, found := v.GetAttribute("yes_votes")
+			s.True(found)
+			s.Equal("100", yesVotes.Value)
+
+			noVotes, found := v.GetAttribute("no_votes")
+			s.True(found)
+			s.Equal("0", noVotes.Value)
+
+			propID, found := v.GetAttribute("proposal_id")
+			s.True(found)
+			s.Equal("0", propID.Value)
+
+			execErr, found := v.GetAttribute("exec_err")
+			s.True(found)
+			s.Equal("<nil>", execErr.Value)
+
+			rejectErr, found := v.GetAttribute("reject_err")
+			s.True(found)
+			s.Equal("<nil>", rejectErr.Value)
+		}
+	}
+	s.True(foundPropResult)
+
+	balance = s.app.BankKeeper.GetBalance(ctx, randAcc, "stake")
+	s.Equal(int64(100), balance.Amount.Int64())
+
+	// try to execute again, should fail
+	err = s.executeProposal(ctx, accountAddr, s.members[0], 0)
+	s.Error(err)
+}
+
+// TestConfigUpdate creates a multisig with 1 member, adds 2 more members and
+// changes the config to require 2/3 majority (also through a proposal).
+func (s *IntegrationTestSuite) TestConfigUpdate() {
+	ctx := sdk.NewContext(s.app.CommitMultiStore(), false, s.app.Logger()).WithHeaderInfo(header.Info{
+		Time: time.Now(),
+	})
+
+	initialMembers := map[string]uint64{
+		s.membersAddr[0]: 100,
+	}
+	accountAddr, accAddrStr := s.initAccount(ctx, s.members[0], initialMembers)
+
+	// Add 2 members and pass the proposal
+	// create proposal
+	updateMsg := &v1.MsgUpdateConfig{
+		UpdateMembers: []*v1.Member{
+			{
+				Address: s.membersAddr[1],
+				Weight:  100,
+			},
+			{
+				Address: s.membersAddr[2],
+				Weight:  100,
+			},
+		},
+		Config: &v1.Config{
+			Threshold:      200, // 3 members with 100 power each, 2/3 majority
+			Quorum:         200,
+			VotingPeriod:   120,
+			Revote:         false,
+			EarlyExecution: false,
+		},
+	}
+
+	msgExec := &accountsv1.MsgExecute{
+		Sender:  accAddrStr,
+		Target:  accAddrStr,
+		Message: codectypes.UnsafePackAny(updateMsg),
+		Funds:   []sdk.Coin{},
+	}
+
+	s.createProposal(ctx, accountAddr, s.members[0], codectypes.UnsafePackAny(msgExec))
+
+	// vote
+	voteReq := &v1.MsgVote{
+		ProposalId: 0,
+		Vote:       v1.VoteOption_VOTE_OPTION_YES,
+	}
+
+	err := s.executeTx(ctx, voteReq, accountAddr, s.members[0])
+	s.NoError(err)
+
+	err = s.executeProposal(ctx, accountAddr, s.members[0], 0)
+	s.NoError(err)
+
+	// get members
+	res, err := s.queryAcc(ctx, &v1.QueryConfig{}, accountAddr)
+	s.NoError(err)
+	resp := res.(*v1.QueryConfigResponse)
+	s.Len(resp.Members, 3)
+	s.Equal(int64(200), resp.Config.Threshold)
+
+	// Try to remove a member, but it doesn't reach passing threshold
+	// create proposal
+	msgExec = &accountsv1.MsgExecute{
+		Sender: accAddrStr,
+		Target: accAddrStr,
+		Message: codectypes.UnsafePackAny(&v1.MsgUpdateConfig{
+			UpdateMembers: []*v1.Member{
+				{
+					Address: s.membersAddr[1],
+					Weight:  0,
+				},
+			},
+			Config: &v1.Config{
+				Threshold:      200, // 3 members with 100 power each, 2/3 majority
+				Quorum:         200,
+				VotingPeriod:   120,
+				Revote:         false,
+				EarlyExecution: false,
+			},
+		}),
+		Funds: []sdk.Coin{},
+	}
+
+	s.createProposal(ctx, accountAddr, s.members[0], codectypes.UnsafePackAny(msgExec))
+
+	// vote
+	voteReq = &v1.MsgVote{
+		ProposalId: 1,
+		Vote:       v1.VoteOption_VOTE_OPTION_NO,
+	}
+
+	err = s.executeTx(ctx, voteReq, accountAddr, s.members[0])
+	s.NoError(err)
+
+	// need to wait until voting period is over because we disabled early execution on the last
+	// config update
+	err = s.executeProposal(ctx, accountAddr, s.members[0], 0)
+	s.ErrorContains(err, "voting period has not ended yet, and early execution is not enabled")
+
+	// vote with member 1
+	voteReq = &v1.MsgVote{
+		ProposalId: 1,
+		Vote:       v1.VoteOption_VOTE_OPTION_NO,
+	}
+
+	err = s.executeTx(ctx, voteReq, accountAddr, s.members[1])
+	s.NoError(err)
+
+	// need to wait until voting period is over because we disabled early execution on the last
+	// config update
+	err = s.executeProposal(ctx, accountAddr, s.members[0], 1)
+	s.ErrorContains(err, "voting period has not ended yet, and early execution is not enabled")
+
+	headerInfo := ctx.HeaderInfo()
+	headerInfo.Time = headerInfo.Time.Add(time.Second * 121)
+	ctx = ctx.WithHeaderInfo(headerInfo)
+
+	// now it should work, but the proposal will fail
+	err = s.executeProposal(ctx, accountAddr, s.members[0], 1)
+	s.NoError(err)
+
+	foundPropResult := false
+	for _, v := range ctx.EventManager().Events() {
+		if v.Type == "proposal_tally" {
+			propID, found := v.GetAttribute("proposal_id")
+			s.True(found)
+
+			if propID.Value == "1" {
+				foundPropResult = true
+				status, found := v.GetAttribute("status")
+				s.True(found)
+				s.Equal(v1.ProposalStatus_PROPOSAL_STATUS_REJECTED.String(), status.Value)
+
+				// exec_err is nil because the proposal didn't execute
+				execErr, found := v.GetAttribute("exec_err")
+				s.True(found)
+				s.Equal("<nil>", execErr.Value)
+
+				rejectErr, found := v.GetAttribute("reject_err")
+				s.True(found)
+				s.Equal("threshold not reached", rejectErr.Value)
+			}
+		}
+	}
+	s.True(foundPropResult)
+
+	// get members
+	res, err = s.queryAcc(ctx, &v1.QueryConfig{}, accountAddr)
+	s.NoError(err)
+	resp = res.(*v1.QueryConfigResponse)
+	s.Len(resp.Members, 3)
+	s.Equal(int64(200), resp.Config.Threshold)
+}

tests/integration/accounts/multisig/test_suite.go

@@ -0,0 +1,115 @@
+package multisig
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+
+	"cosmossdk.io/core/transaction"
+	"cosmossdk.io/math"
+	"cosmossdk.io/simapp"
+	v1 "cosmossdk.io/x/accounts/defaults/multisig/v1"
+	"cosmossdk.io/x/bank/testutil"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type IntegrationTestSuite struct {
+	suite.Suite
+
+	app         *simapp.SimApp
+	members     []sdk.AccAddress
+	membersAddr []string
+}
+
+func NewIntegrationTestSuite() *IntegrationTestSuite {
+	return &IntegrationTestSuite{}
+}
+
+func (s *IntegrationTestSuite) SetupSuite() {
+	s.app = setupApp(s.T())
+
+	s.members = []sdk.AccAddress{}
+	for i := 0; i < 10; i++ {
+		addr := secp256k1.GenPrivKey().PubKey().Address()
+		addrStr, err := s.app.AuthKeeper.AddressCodec().BytesToString(addr)
+		require.NoError(s.T(), err)
+		s.membersAddr = append(s.membersAddr, addrStr)
+		s.members = append(s.members, sdk.AccAddress(addr))
+	}
+}
+
+func (s *IntegrationTestSuite) TearDownSuite() {}
+
+func setupApp(t *testing.T) *simapp.SimApp {
+	t.Helper()
+	app := simapp.Setup(t, false)
+	return app
+}
+
+func (s *IntegrationTestSuite) executeTx(ctx context.Context, msg sdk.Msg, accAddr, sender []byte) error {
+	_, err := s.app.AccountsKeeper.Execute(ctx, accAddr, sender, msg, nil)
+	return err
+}
+
+func (s *IntegrationTestSuite) queryAcc(ctx context.Context, req sdk.Msg, accAddr []byte) (transaction.Msg, error) {
+	resp, err := s.app.AccountsKeeper.Query(ctx, accAddr, req)
+	return resp, err
+}
+
+func (s *IntegrationTestSuite) fundAccount(ctx context.Context, addr sdk.AccAddress, amt sdk.Coins) {
+	require.NoError(s.T(), testutil.FundAccount(ctx, s.app.BankKeeper, addr, amt))
+}
+
+// initAccount initializes a multisig account with the given members and powers
+// and returns the account address
+func (s *IntegrationTestSuite) initAccount(ctx context.Context, sender []byte, membersPowers map[string]uint64) ([]byte, string) {
+	s.fundAccount(ctx, sender, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000000))})
+
+	members := []*v1.Member{}
+	for addrStr, power := range membersPowers {
+		members = append(members, &v1.Member{Address: addrStr, Weight: power})
+	}
+
+	_, accountAddr, err := s.app.AccountsKeeper.Init(ctx, "multisig", sender,
+		&v1.MsgInit{
+			Members: members,
+			Config: &v1.Config{
+				Threshold:      100,
+				Quorum:         100,
+				VotingPeriod:   120,
+				Revote:         false,
+				EarlyExecution: true,
+			},
+		}, sdk.Coins{sdk.NewCoin("stake", math.NewInt(1000))})
+	s.NoError(err)
+
+	accountAddrStr, err := s.app.AuthKeeper.AddressCodec().BytesToString(accountAddr)
+	s.NoError(err)
+
+	return accountAddr, accountAddrStr
+}
+
+// createProposal
+func (s *IntegrationTestSuite) createProposal(ctx context.Context, accAddr, sender []byte, msgs ...*codectypes.Any) {
+	propReq := &v1.MsgCreateProposal{
+		Proposal: &v1.Proposal{
+			Title:    "test",
+			Summary:  "test",
+			Messages: msgs,
+		},
+	}
+	err := s.executeTx(ctx, propReq, accAddr, sender)
+	s.NoError(err)
+}
+
+func (s *IntegrationTestSuite) executeProposal(ctx context.Context, accAddr, sender []byte, proposalID uint64) error {
+	execReq := &v1.MsgExecuteProposal{
+		ProposalId: proposalID,
+	}
+	return s.executeTx(ctx, execReq, accAddr, sender)
+}

tests/integration/accounts/wiring_test.go

@@ -0,0 +1,67 @@
+//go:build app_v1
+
+package accounts
+
+import (
+	"testing"
+
+	"cosmossdk.io/core/header"
+	storetypes "cosmossdk.io/store/types"
+	counterv1 "cosmossdk.io/x/accounts/testing/counter/v1"
+	"cosmossdk.io/x/bank/testutil"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+)
+
+// TestDependencies aims to test wiring between different account components,
+// inherited from the runtime, specifically:
+// - address codec
+// - binary codec
+// - header service
+// - gas service
+// - funds
+func TestDependencies(t *testing.T) {
+	app := setupApp(t)
+	ak := app.AccountsKeeper
+	ctx := sdk.NewContext(app.CommitMultiStore(), false, app.Logger()).WithHeaderInfo(header.Info{ChainID: "chain-id"})
+	ctx = ctx.WithGasMeter(storetypes.NewGasMeter(500_000))
+
+	_, counterAddr, err := ak.Init(ctx, "counter", accCreator, &counterv1.MsgInit{
+		InitialValue: 0,
+	}, nil)
+	require.NoError(t, err)
+	// test dependencies
+	creatorInitFunds := sdk.NewCoins(sdk.NewInt64Coin("stake", 100_000))
+	err = testutil.FundAccount(ctx, app.BankKeeper, accCreator, creatorInitFunds)
+	require.NoError(t, err)
+	sentFunds := sdk.NewCoins(sdk.NewInt64Coin("stake", 50_000))
+	r, err := ak.Execute(
+		ctx,
+		counterAddr,
+		accCreator,
+		&counterv1.MsgTestDependencies{},
+		sentFunds,
+	)
+	require.NoError(t, err)
+	res := r.(*counterv1.MsgTestDependenciesResponse)
+
+	// test gas
+	require.NotZero(t, res.BeforeGas)
+	require.NotZero(t, res.AfterGas)
+	require.Equal(t, int(uint64(10)), int(res.AfterGas-res.BeforeGas))
+
+	// test header service
+	require.Equal(t, ctx.HeaderInfo().ChainID, res.ChainId)
+
+	// test address codec
+	wantAddr, err := app.AuthKeeper.AddressCodec().BytesToString(counterAddr)
+	require.NoError(t, err)
+	require.Equal(t, wantAddr, res.Address)
+
+	// test funds
+	creatorFunds := app.BankKeeper.GetAllBalances(ctx, accCreator)
+	require.Equal(t, creatorInitFunds.Sub(sentFunds...), creatorFunds)
+
+	accFunds := app.BankKeeper.GetAllBalances(ctx, counterAddr)
+	require.Equal(t, sentFunds, accFunds)
+}

tests/integration/auth/keeper/account_retriever_test.go

@@ -0,0 +1,46 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	authTest "github.com/cosmos/cosmos-sdk/tests/integration/auth/keeper"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	"github.com/cosmos/cosmos-sdk/x/auth/types"
+)
+
+func TestAccountRetriever(t *testing.T) {
+	cfg, err := network.DefaultConfigWithAppConfig(authTest.AppConfig)
+	require.NoError(t, err)
+	cfg.NumValidators = 1
+
+	network, err := network.New(t, t.TempDir(), cfg)
+	require.NoError(t, err)
+	defer network.Cleanup()
+
+	_, err = network.WaitForHeight(3)
+	require.NoError(t, err)
+
+	val := network.GetValidators()[0]
+	clientCtx := val.GetClientCtx()
+	ar := types.AccountRetriever{}
+
+	clientCtx = clientCtx.WithHeight(2)
+
+	acc, err := ar.GetAccount(clientCtx, val.GetAddress())
+	require.NoError(t, err)
+	require.NotNil(t, acc)
+
+	acc, height, err := ar.GetAccountWithHeight(clientCtx, val.GetAddress())
+	require.NoError(t, err)
+	require.NotNil(t, acc)
+	require.Equal(t, height, int64(2))
+
+	require.NoError(t, ar.EnsureExists(clientCtx, val.GetAddress()))
+
+	accNum, accSeq, err := ar.GetAccountNumberSequence(clientCtx, val.GetAddress())
+	require.NoError(t, err)
+	require.Equal(t, accNum, uint64(0))
+	require.Equal(t, accSeq, uint64(1))
+}

tests/integration/auth/keeper/app_config.go

@@ -0,0 +1,26 @@
+package keeper
+
+import (
+	_ "cosmossdk.io/x/accounts"  // import as blank for app wiring
+	_ "cosmossdk.io/x/bank"      // import as blank for app wiring
+	_ "cosmossdk.io/x/consensus" // import as blank for app wiring
+	_ "cosmossdk.io/x/staking"   // import as blank for app wiring
+
+	"github.com/cosmos/cosmos-sdk/testutil/configurator"
+	_ "github.com/cosmos/cosmos-sdk/x/auth"           // import as blank for app wiring
+	_ "github.com/cosmos/cosmos-sdk/x/auth/tx/config" // import as blank for app wiring``
+	_ "github.com/cosmos/cosmos-sdk/x/auth/vesting"   // import as blank for app wiring
+	_ "github.com/cosmos/cosmos-sdk/x/genutil"        // import as blank for app wiring
+)
+
+var AppConfig = configurator.NewAppConfig(
+	configurator.AccountsModule(),
+	configurator.AuthModule(),
+	configurator.BankModule(),
+	configurator.VestingModule(),
+	configurator.StakingModule(),
+	configurator.TxModule(),
+	configurator.ValidateModule(),
+	configurator.ConsensusModule(),
+	configurator.GenutilModule(),
+)

tests/integration/auth/keeper/keeper_bench_test.go

@@ -0,0 +1,67 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"cosmossdk.io/depinject"
+	"cosmossdk.io/log"
+
+	authTest "github.com/cosmos/cosmos-sdk/tests/integration/auth/keeper"
+	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/auth/keeper"
+)
+
+func BenchmarkAccountMapperGetAccountFound(b *testing.B) {
+	b.ReportAllocs()
+	var accountKeeper keeper.AccountKeeper
+	app, err := simtestutil.Setup(
+		depinject.Configs(
+			depinject.Supply(log.NewNopLogger()),
+			authTest.AppConfig,
+		),
+		&accountKeeper,
+	)
+	require.NoError(b, err)
+
+	ctx := app.BaseApp.NewContext(false)
+
+	// assumes b.N < 2**24
+	for i := 0; i < b.N; i++ {
+		arr := []byte{byte((i & 0xFF0000) >> 16), byte((i & 0xFF00) >> 8), byte(i & 0xFF)}
+		addr := sdk.AccAddress(arr)
+		acc := accountKeeper.NewAccountWithAddress(ctx, addr)
+		accountKeeper.SetAccount(ctx, acc)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		arr := []byte{byte((i & 0xFF0000) >> 16), byte((i & 0xFF00) >> 8), byte(i & 0xFF)}
+		accountKeeper.GetAccount(ctx, sdk.AccAddress(arr))
+	}
+}
+
+func BenchmarkAccountMapperSetAccount(b *testing.B) {
+	b.ReportAllocs()
+	var accountKeeper keeper.AccountKeeper
+	app, err := simtestutil.Setup(
+		depinject.Configs(
+			depinject.Supply(log.NewNopLogger()),
+			authTest.AppConfig,
+		), &accountKeeper)
+	require.NoError(b, err)
+
+	ctx := app.BaseApp.NewContext(false)
+
+	b.ResetTimer()
+
+	// assumes b.N < 2**24
+	for i := 0; i < b.N; i++ {
+		arr := []byte{byte((i & 0xFF0000) >> 16), byte((i & 0xFF00) >> 8), byte(i & 0xFF)}
+		addr := sdk.AccAddress(arr)
+		acc := accountKeeper.NewAccountWithAddress(ctx, addr)
+		accountKeeper.SetAccount(ctx, acc)
+	}
+}

tests/integration/auth/keeper/module_test.go

@@ -0,0 +1,30 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"cosmossdk.io/depinject"
+	"cosmossdk.io/log"
+
+	authTest "github.com/cosmos/cosmos-sdk/tests/integration/auth/keeper"
+	simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
+	"github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	"github.com/cosmos/cosmos-sdk/x/auth/types"
+)
+
+func TestItCreatesModuleAccountOnInitBlock(t *testing.T) {
+	var accountKeeper keeper.AccountKeeper
+	app, err := simtestutil.SetupAtGenesis(
+		depinject.Configs(
+			authTest.AppConfig,
+			depinject.Supply(log.NewNopLogger()),
+		),
+		&accountKeeper)
+	require.NoError(t, err)
+
+	ctx := app.BaseApp.NewContext(false)
+	acc := accountKeeper.GetAccount(ctx, types.NewModuleAddress(types.FeeCollectorName))
+	require.NotNil(t, acc)
+}

tests/integration/tx/benchmark/benchmarks_test.go

@@ -0,0 +1,191 @@
+package benchmark_test
+
+import (
+	"context"
+	"testing"
+
+	"gotest.tools/v3/assert"
+
+	sdkmath "cosmossdk.io/math"
+	"cosmossdk.io/simapp"
+	banktypes "cosmossdk.io/x/bank/types"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	clienttx "github.com/cosmos/cosmos-sdk/client/tx"
+	"github.com/cosmos/cosmos-sdk/testutil/cli"
+	"github.com/cosmos/cosmos-sdk/testutil/network"
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/tx"
+	"github.com/cosmos/cosmos-sdk/types/tx/signing"
+	authclient "github.com/cosmos/cosmos-sdk/x/auth/client"
+)
+
+type TxBenchmarkSuite struct {
+	cfg     network.Config
+	network network.NetworkI
+
+	txHeight    int64
+	queryClient tx.ServiceClient
+}
+
+// BenchmarkTx is lifted from TestSuite from this package, with irrelevant state checks removed.
+//
+// Benchmark results:
+//
+// On a M1 macOS, on commit ab77fe20d3c00ef4cb73dfd0c803c4593a3c8233:
+//
+//	BenchmarkTx-8 4108 268935 ns/op
+//
+// By comparison, the benchmark modified for v0.47.0:
+//
+//	BenchmarkTx-8 3772 301750 ns/op
+func BenchmarkTx(b *testing.B) {
+	s := NewTxBenchmarkSuite(b)
+	b.Cleanup(s.Close)
+
+	val := s.network.GetValidators()[0]
+	txBuilder := mkTxBuilder(b, s)
+	// Convert the txBuilder to a tx.Tx.
+	protoTx, err := txBuilder.GetTx().(interface{ AsTx() (*tx.Tx, error) }).AsTx()
+	assert.NilError(b, err)
+	// Encode the txBuilder to txBytes.
+	txBytes, err := val.GetClientCtx().TxConfig.TxEncoder()(txBuilder.GetTx())
+	assert.NilError(b, err)
+
+	testCases := []struct {
+		name string
+		req  *tx.SimulateRequest
+	}{
+		{"valid request with proto tx (deprecated)", &tx.SimulateRequest{Tx: protoTx}},
+		{"valid request with tx_bytes", &tx.SimulateRequest{TxBytes: txBytes}},
+	}
+
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		for _, tc := range testCases {
+			// Broadcast the tx via gRPC via the validator's clientCtx (which goes
+			// through Tendermint).
+			res, err := s.queryClient.Simulate(context.Background(), tc.req)
+			assert.NilError(b, err)
+			// Check the result and gas used are correct.
+			//
+			// The 10 events are:
+			// - Sending Fee to the pool (3 events): coin_spent, coin_received, transfer
+			// - tx.* events (3 events): tx.fee, tx.acc_seq, tx.signature
+			// - Sending Amount to recipient (3 events): coin_spent, coin_received, transfer and message.sender=<val1>
+			// - Msg events (1 event): message.module=bank, message.action=/cosmos.bank.v1beta1.MsgSend and message.sender=<val1> (all in one event)
+			assert.Equal(b, 10, len(res.GetResult().GetEvents()))
+			assert.Assert(b, res.GetGasInfo().GetGasUsed() > 0) // Gas used sometimes change, just check it's not empty.
+		}
+	}
+}
+
+func NewTxBenchmarkSuite(tb testing.TB) *TxBenchmarkSuite {
+	tb.Helper()
+
+	s := new(TxBenchmarkSuite)
+
+	cfg := network.DefaultConfig(simapp.NewTestNetworkFixture)
+	cfg.NumValidators = 1
+	s.cfg = cfg
+
+	var err error
+	s.network, err = network.New(tb, tb.TempDir(), s.cfg)
+	assert.NilError(tb, err)
+
+	val := s.network.GetValidators()[0]
+	assert.NilError(tb, s.network.WaitForNextBlock())
+
+	s.queryClient = tx.NewServiceClient(val.GetClientCtx())
+
+	msgSend := &banktypes.MsgSend{
+		FromAddress: val.GetAddress().String(),
+		ToAddress:   val.GetAddress().String(),
+		Amount:      sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdkmath.NewInt(10))),
+	}
+
+	// Create a new MsgSend tx from val to itself.
+	out, err := cli.SubmitTestTx(
+		val.GetClientCtx(),
+		msgSend,
+		val.GetAddress(),
+		cli.TestTxConfig{
+			Memo: "foobar",
+		},
+	)
+
+	assert.NilError(tb, err)
+
+	var txRes sdk.TxResponse
+	assert.NilError(tb, val.GetClientCtx().Codec.UnmarshalJSON(out.Bytes(), &txRes))
+	assert.Equal(tb, uint32(0), txRes.Code, txRes)
+
+	msgSend1 := &banktypes.MsgSend{
+		FromAddress: val.GetAddress().String(),
+		ToAddress:   val.GetAddress().String(),
+		Amount:      sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdkmath.NewInt(1))),
+	}
+
+	out, err = cli.SubmitTestTx(
+		val.GetClientCtx(),
+		msgSend1,
+		val.GetAddress(),
+		cli.TestTxConfig{
+			Offline: true,
+			AccNum:  0,
+			Seq:     2,
+			Memo:    "foobar",
+		},
+	)
+
+	assert.NilError(tb, err)
+	var tr sdk.TxResponse
+	assert.NilError(tb, val.GetClientCtx().Codec.UnmarshalJSON(out.Bytes(), &tr))
+	assert.Equal(tb, uint32(0), tr.Code)
+
+	resp, err := cli.GetTxResponse(s.network, val.GetClientCtx(), tr.TxHash)
+	assert.NilError(tb, err)
+	s.txHeight = resp.Height
+	return s
+}
+
+func (s *TxBenchmarkSuite) Close() {
+	s.network.Cleanup()
+}
+
+func mkTxBuilder(tb testing.TB, s *TxBenchmarkSuite) client.TxBuilder {
+	tb.Helper()
+
+	val := s.network.GetValidators()[0]
+	assert.NilError(tb, s.network.WaitForNextBlock())
+
+	// prepare txBuilder with msg
+	txBuilder := val.GetClientCtx().TxConfig.NewTxBuilder()
+	feeAmount := sdk.Coins{sdk.NewInt64Coin(s.cfg.BondDenom, 10)}
+	gasLimit := testdata.NewTestGasLimit()
+	assert.NilError(tb,
+		txBuilder.SetMsgs(&banktypes.MsgSend{
+			FromAddress: val.GetAddress().String(),
+			ToAddress:   val.GetAddress().String(),
+			Amount:      sdk.Coins{sdk.NewInt64Coin(s.cfg.BondDenom, 10)},
+		}),
+	)
+	txBuilder.SetFeeAmount(feeAmount)
+	txBuilder.SetGasLimit(gasLimit)
+	txBuilder.SetMemo("foobar")
+
+	// setup txFactory
+	txFactory := clienttx.Factory{}.
+		WithChainID(val.GetClientCtx().ChainID).
+		WithKeybase(val.GetClientCtx().Keyring).
+		WithTxConfig(val.GetClientCtx().TxConfig).
+		WithSignMode(signing.SignMode_SIGN_MODE_DIRECT)
+
+	// Sign Tx.
+	err := authclient.SignTx(txFactory, val.GetClientCtx(), val.GetMoniker(), txBuilder, false, true)
+	assert.NilError(tb, err)
+
+	return txBuilder
+}