diff --git a/x/dao/keeper/integration_test.go b/x/dao/keeper/integration_test.go index c4bd28ad..3fee95b3 100644 --- a/x/dao/keeper/integration_test.go +++ b/x/dao/keeper/integration_test.go @@ -10,28 +10,30 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + "github.com/haqq-network/haqq/crypto/ethsecp256k1" "github.com/haqq-network/haqq/testutil" "github.com/haqq-network/haqq/utils" "github.com/haqq-network/haqq/x/dao/types" ) -var _ = Describe("Feemarket", func() { +var _ = Describe("United Contributors DAO", func() { var ( - daoModuleAcc authtypes.ModuleAccountI - fundMsg *types.MsgFund - err error + daoModuleAcc authtypes.ModuleAccountI + fundMsg *types.MsgFund + transferOwnershipMsg *types.MsgTransferOwnership + err error ) - Describe("Performing Cosmos transactions", func() { - oneHundred, _ := sdk.NewIntFromString("100000000000000000000") - oneHundredIslm := sdk.NewCoin(utils.BaseDenom, oneHundred) - oneIslm := sdk.NewInt64Coin(utils.BaseDenom, 1000000000000000000) - threeInvalid := sdk.NewInt64Coin("invalid", 3000000000000000000) - fiveLiquid1 := sdk.NewInt64Coin("aLIQUID1", 5000000000000000000) - sevenLiquid75 := sdk.NewInt64Coin("aLIQUID75", 7000000000000000000) - nineLiquidInvalid := sdk.NewInt64Coin("aLIQUID", 9000000000000000000) - gasPrice := sdkmath.NewInt(1000000000) + oneHundred, _ := sdk.NewIntFromString("100000000000000000000") + oneHundredIslm := sdk.NewCoin(utils.BaseDenom, oneHundred) + oneIslm := sdk.NewInt64Coin(utils.BaseDenom, 1000000000000000000) + threeInvalid := sdk.NewInt64Coin("invalid", 3000000000000000000) + fiveLiquid1 := sdk.NewInt64Coin("aLIQUID1", 5000000000000000000) + sevenLiquid75 := sdk.NewInt64Coin("aLIQUID75", 7000000000000000000) + nineLiquidInvalid := sdk.NewInt64Coin("aLIQUID", 9000000000000000000) + gasPrice := sdkmath.NewInt(1000000000) + Describe("Fund transactions", func() { Context("with invalid denom", func() { BeforeEach(func() { s.SetupTest() @@ -290,4 +292,326 @@ var _ = Describe("Feemarket", func() { }) }) }) + + Describe("Transfer Ownership transactions", func() { + newOwnerPriv, err := ethsecp256k1.GenerateKey() + newOwnerAddr := sdk.AccAddress(newOwnerPriv.PubKey().Address().Bytes()) + + Context("basic validation", func() { + BeforeEach(func() { + s.SetupTest() + + err = testutil.FundAccount(s.ctx, s.app.BankKeeper, s.address, sdk.NewCoins(oneHundredIslm)) + s.Require().NoError(err) + + s.Commit() + }) + + It("should fail - invalid owner address", func() { + // TX Process + transferOwnershipMsg = &types.MsgTransferOwnership{ + Owner: "haqq1", + NewOwner: newOwnerAddr.String(), + } + + _, err = testutil.DeliverTx(s.ctx, s.app, s.priv, &gasPrice, transferOwnershipMsg) + Expect(err).NotTo(BeNil(), "transaction should fail") + Expect(err.Error()).To(ContainSubstring("invalid owner address")) + s.Commit() + }) + + It("should fail - invalid new owner address", func() { + // TX Process + transferOwnershipMsg = &types.MsgTransferOwnership{ + Owner: s.address.String(), + NewOwner: "haqq1", + } + + _, err = testutil.DeliverTx(s.ctx, s.app, s.priv, &gasPrice, transferOwnershipMsg) + Expect(err).NotTo(BeNil(), "transaction should fail") + Expect(err.Error()).To(ContainSubstring("invalid new owner address")) + s.Commit() + }) + }) + + Context("with non-member as owner", func() { + BeforeEach(func() { + s.SetupTest() + + err = testutil.FundAccount(s.ctx, s.app.BankKeeper, s.address, sdk.NewCoins(oneHundredIslm)) + s.Require().NoError(err) + + s.Commit() + }) + + It("should fail - not eligible", func() { + daoTotalBalanceBefore, err := s.queryClient.TotalBalance(s.ctx, &types.QueryTotalBalanceRequest{}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoTotalBalanceBefore.TotalBalance.IsZero()).To(BeTrue(), "dao total balance should be empty") + + daoAddressBalanceBefore, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: s.address.String()}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoAddressBalanceBefore.Balances.IsZero()).To(BeTrue(), "dao address balance should be empty") + + // TX Process + transferOwnershipMsg = types.NewMsgTransferOwnership(s.address, newOwnerAddr) + + _, err = testutil.DeliverTx(s.ctx, s.app, s.priv, &gasPrice, transferOwnershipMsg) + Expect(err).NotTo(BeNil(), "transaction should fail") + Expect(err.Error()).To(ContainSubstring("not eligible"), "error message should be correct") + s.Commit() + }) + }) + + Context("with member as owner and non-member as new owner", func() { + BeforeEach(func() { + s.SetupTest() + + err = testutil.FundAccount(s.ctx, s.app.BankKeeper, s.address, sdk.NewCoins(oneHundredIslm, fiveLiquid1)) + s.Require().NoError(err) + + s.Commit() + }) + + It("successfully transferred", func() { + daoModuleAddressBankBalanceBeforeFund := s.app.BankKeeper.GetAllBalances(s.ctx, daoModuleAcc.GetAddress()) + Expect(daoModuleAddressBankBalanceBeforeFund.IsZero()).To(BeTrue(), "dao module account bank balance should be empty") + + daoTotalBalanceBeforeFund, err := s.queryClient.TotalBalance(s.ctx, &types.QueryTotalBalanceRequest{}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoTotalBalanceBeforeFund.TotalBalance.IsZero()).To(BeTrue(), "dao total balance should be empty") + + daoOwnerAddressBalanceBeforeFund, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: s.address.String()}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoOwnerAddressBalanceBeforeFund.Balances.IsZero()).To(BeTrue(), "dao module address balance should be empty") + + // Fund TX Process + fundMsg = types.NewMsgFund( + sdk.NewCoins(oneIslm, fiveLiquid1), + s.address, + ) + _, err = testutil.DeliverTx(s.ctx, s.app, s.priv, &gasPrice, fundMsg) + Expect(err).To(BeNil(), "transaction should have succeed") + s.Commit() + + // Check balances after funding TX + daoModuleAddressBankBalanceAfterFundIslm := s.app.BankKeeper.GetBalance(s.ctx, daoModuleAcc.GetAddress(), oneIslm.Denom) + Expect(daoModuleAddressBankBalanceAfterFundIslm.Amount.String()).To(Equal(oneIslm.Amount.String()), "dao account should have received the funds") + daoModuleAddressBankBalanceAfterFundLiquid := s.app.BankKeeper.GetBalance(s.ctx, daoModuleAcc.GetAddress(), fiveLiquid1.Denom) + Expect(daoModuleAddressBankBalanceAfterFundLiquid.Amount.String()).To(Equal(fiveLiquid1.Amount.String()), "dao account should have received the funds") + + daoTotalBalanceAfterFund, err := s.queryClient.TotalBalance(s.ctx, &types.QueryTotalBalanceRequest{}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoTotalBalanceAfterFund.TotalBalance.IsZero()).To(BeFalse(), "dao total balance should not be empty") + ok, islmAmountAfterFund := daoTotalBalanceAfterFund.TotalBalance.Find(oneIslm.Denom) + Expect(ok).To(BeTrue(), "dao total balance should have received the funds") + Expect(islmAmountAfterFund.String()).To(Equal(oneIslm.String()), "dao total balance should have received the funds") + ok, liquidAmountAfterFund := daoTotalBalanceAfterFund.TotalBalance.Find(fiveLiquid1.Denom) + Expect(ok).To(BeTrue(), "dao total balance should have received the funds") + Expect(liquidAmountAfterFund.String()).To(Equal(fiveLiquid1.String()), "dao total balance should have received the funds") + + daoOwnerAddressAllBalancesAfterFund, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: s.address.String()}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoOwnerAddressAllBalancesAfterFund.Balances.IsZero()).To(BeFalse(), "dao account balance should not be empty") + okAcc, islmAccAmount := daoOwnerAddressAllBalancesAfterFund.Balances.Find(oneIslm.Denom) + Expect(okAcc).To(BeTrue(), "dao address balance should have received the funds") + Expect(islmAccAmount.String()).To(Equal(oneIslm.String()), "dao address balance should have received the funds") + okAcc, liquidAccAmount := daoOwnerAddressAllBalancesAfterFund.Balances.Find(fiveLiquid1.Denom) + Expect(okAcc).To(BeTrue(), "dao address balance should have received the funds") + Expect(liquidAccAmount.String()).To(Equal(fiveLiquid1.String()), "dao address balance should have received the funds") + + daoOwnerAddressIslmBalanceAfterFund, err := s.queryClient.Balance(s.ctx, &types.QueryBalanceRequest{Address: s.address.String(), Denom: oneIslm.Denom}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoOwnerAddressIslmBalanceAfterFund.Balance.String()).To(Equal(oneIslm.String()), "dao address balance should have received the funds") + daoOwnerAddressLiquidBalanceAfterFund, err := s.queryClient.Balance(s.ctx, &types.QueryBalanceRequest{Address: s.address.String(), Denom: fiveLiquid1.Denom}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoOwnerAddressLiquidBalanceAfterFund.Balance.String()).To(Equal(fiveLiquid1.String()), "dao address balance should have received the funds") + + // Store new owner address balances before transfer ownership + daoNewOwnerAddressAllBalancesBeforeTransfer, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: newOwnerAddr.String()}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoNewOwnerAddressAllBalancesBeforeTransfer.Balances.IsZero()).To(BeTrue(), "dao new owner address balance should be empty") + + // Transfer TX Process + transferOwnershipMsg = types.NewMsgTransferOwnership(s.address, newOwnerAddr) + _, err = testutil.DeliverTx(s.ctx, s.app, s.priv, &gasPrice, transferOwnershipMsg) + Expect(err).To(BeNil(), "transaction should succeed") + s.Commit() + + // Checks after transfer ownership + // Module bank balance shouldn't change + daoModuleAddressBankBalanceAfterTransferIslm := s.app.BankKeeper.GetBalance(s.ctx, daoModuleAcc.GetAddress(), oneIslm.Denom) + Expect(daoModuleAddressBankBalanceAfterTransferIslm.Amount.String()).To(Equal(daoModuleAddressBankBalanceAfterFundIslm.Amount.String())) + daoModuleAddressBankBalanceAfterTransferLiquid := s.app.BankKeeper.GetBalance(s.ctx, daoModuleAcc.GetAddress(), fiveLiquid1.Denom) + Expect(daoModuleAddressBankBalanceAfterTransferLiquid.Amount.String()).To(Equal(daoModuleAddressBankBalanceAfterFundLiquid.Amount.String())) + + // Module internal total balance shouldn't change + daoTotalBalanceAfterTransfer, err := s.queryClient.TotalBalance(s.ctx, &types.QueryTotalBalanceRequest{}) + Expect(err).To(BeNil()) + Expect(daoTotalBalanceAfterTransfer.TotalBalance.IsZero()).To(BeFalse()) + ok, islmAmountAfterTransfer := daoTotalBalanceAfterTransfer.TotalBalance.Find(oneIslm.Denom) + Expect(ok).To(BeTrue()) + Expect(islmAmountAfterTransfer.String()).To(Equal(islmAmountAfterFund.String())) + ok, liquidAmountAfterTransfer := daoTotalBalanceAfterTransfer.TotalBalance.Find(fiveLiquid1.Denom) + Expect(ok).To(BeTrue()) + Expect(liquidAmountAfterTransfer.String()).To(Equal(liquidAmountAfterFund.String())) + + // Old owner internal dao balance should become empty + daoOwnerAddressAllBalancesAfterTransfer, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: s.address.String()}) + Expect(err).To(BeNil()) + Expect(daoOwnerAddressAllBalancesAfterTransfer.Balances.IsZero()).To(BeTrue()) + + // All tokens should be transferred to new owner + daoNewOwnerAddressAllBalancesAfterTransfer, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: newOwnerAddr.String()}) + Expect(err).To(BeNil()) + Expect(daoNewOwnerAddressAllBalancesAfterTransfer.Balances.IsZero()).To(BeFalse()) + okNewAcc, islmNewAccAmount := daoNewOwnerAddressAllBalancesAfterTransfer.Balances.Find(oneIslm.Denom) + Expect(okNewAcc).To(BeTrue()) + Expect(islmNewAccAmount.String()).To(Equal(oneIslm.String())) + okNewAcc, liquidNewAccAmount := daoNewOwnerAddressAllBalancesAfterTransfer.Balances.Find(fiveLiquid1.Denom) + Expect(okNewAcc).To(BeTrue()) + Expect(liquidNewAccAmount.String()).To(Equal(fiveLiquid1.String())) + daoNewOwnerAddressIslmBalanceAfterTransfer, err := s.queryClient.Balance(s.ctx, &types.QueryBalanceRequest{Address: newOwnerAddr.String(), Denom: oneIslm.Denom}) + Expect(err).To(BeNil()) + Expect(daoNewOwnerAddressIslmBalanceAfterTransfer.Balance.String()).To(Equal(oneIslm.String())) + daoNewOwnerAddressLiquidBalanceAfterTransfer, err := s.queryClient.Balance(s.ctx, &types.QueryBalanceRequest{Address: newOwnerAddr.String(), Denom: fiveLiquid1.Denom}) + Expect(err).To(BeNil()) + Expect(daoNewOwnerAddressLiquidBalanceAfterTransfer.Balance.String()).To(Equal(fiveLiquid1.String())) + }) + }) + + Context("with both owner and new owner as members", func() { + BeforeEach(func() { + s.SetupTest() + + // Fund owner account + err = testutil.FundAccount(s.ctx, s.app.BankKeeper, s.address, sdk.NewCoins(oneHundredIslm, fiveLiquid1)) + s.Require().NoError(err) + + // Fund new owner account + err = testutil.FundAccount(s.ctx, s.app.BankKeeper, newOwnerAddr, sdk.NewCoins(oneHundredIslm)) + s.Require().NoError(err) + + s.Commit() + }) + + It("successfully transferred", func() { + daoModuleAddressBankBalanceBeforeFund := s.app.BankKeeper.GetAllBalances(s.ctx, daoModuleAcc.GetAddress()) + Expect(daoModuleAddressBankBalanceBeforeFund.IsZero()).To(BeTrue(), "dao module account bank balance should be empty") + + daoTotalBalanceBeforeFund, err := s.queryClient.TotalBalance(s.ctx, &types.QueryTotalBalanceRequest{}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoTotalBalanceBeforeFund.TotalBalance.IsZero()).To(BeTrue(), "dao total balance should be empty") + + daoOwnerAddressBalanceBeforeFund, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: s.address.String()}) + Expect(err).To(BeNil(), "query should have succeed") + Expect(daoOwnerAddressBalanceBeforeFund.Balances.IsZero()).To(BeTrue(), "dao module address balance should be empty") + + // Fund by owner TX Process + fundMsg = types.NewMsgFund( + sdk.NewCoins(oneIslm, fiveLiquid1), + s.address, + ) + _, err = testutil.DeliverTx(s.ctx, s.app, s.priv, &gasPrice, fundMsg) + Expect(err).To(BeNil(), "transaction should have succeed") + s.Commit() + + // Fund by new owner TX Process + twoIslm := oneIslm.Add(oneIslm) + fundMsg = types.NewMsgFund( + sdk.NewCoins(twoIslm), + newOwnerAddr, + ) + _, err = testutil.DeliverTx(s.ctx, s.app, newOwnerPriv, &gasPrice, fundMsg) + Expect(err).To(BeNil(), "transaction should have succeed") + s.Commit() + + // Check balances after funding TX + daoModuleAddressBankBalanceAfterFundIslm := s.app.BankKeeper.GetBalance(s.ctx, daoModuleAcc.GetAddress(), oneIslm.Denom) + Expect(daoModuleAddressBankBalanceAfterFundIslm.Amount.String()).To(Equal(oneIslm.Amount.Add(twoIslm.Amount).String())) + daoModuleAddressBankBalanceAfterFundLiquid := s.app.BankKeeper.GetBalance(s.ctx, daoModuleAcc.GetAddress(), fiveLiquid1.Denom) + Expect(daoModuleAddressBankBalanceAfterFundLiquid.Amount.String()).To(Equal(fiveLiquid1.Amount.String())) + + daoTotalBalanceAfterFund, err := s.queryClient.TotalBalance(s.ctx, &types.QueryTotalBalanceRequest{}) + Expect(err).To(BeNil()) + Expect(daoTotalBalanceAfterFund.TotalBalance.IsZero()).To(BeFalse()) + ok, islmAmountAfterFund := daoTotalBalanceAfterFund.TotalBalance.Find(oneIslm.Denom) + Expect(ok).To(BeTrue()) + Expect(islmAmountAfterFund.String()).To(Equal(oneIslm.Add(twoIslm).String())) + ok, liquidAmountAfterFund := daoTotalBalanceAfterFund.TotalBalance.Find(fiveLiquid1.Denom) + Expect(ok).To(BeTrue()) + Expect(liquidAmountAfterFund.String()).To(Equal(fiveLiquid1.String())) + + daoOwnerAddressAllBalancesAfterFund, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: s.address.String()}) + Expect(err).To(BeNil()) + Expect(daoOwnerAddressAllBalancesAfterFund.Balances.IsZero()).To(BeFalse()) + okAcc, islmAccAmount := daoOwnerAddressAllBalancesAfterFund.Balances.Find(oneIslm.Denom) + Expect(okAcc).To(BeTrue()) + Expect(islmAccAmount.String()).To(Equal(oneIslm.String())) + okAcc, liquidAccAmount := daoOwnerAddressAllBalancesAfterFund.Balances.Find(fiveLiquid1.Denom) + Expect(okAcc).To(BeTrue()) + Expect(liquidAccAmount.String()).To(Equal(fiveLiquid1.String())) + + daoOwnerAddressIslmBalanceAfterFund, err := s.queryClient.Balance(s.ctx, &types.QueryBalanceRequest{Address: s.address.String(), Denom: oneIslm.Denom}) + Expect(err).To(BeNil()) + Expect(daoOwnerAddressIslmBalanceAfterFund.Balance.String()).To(Equal(oneIslm.String())) + daoOwnerAddressLiquidBalanceAfterFund, err := s.queryClient.Balance(s.ctx, &types.QueryBalanceRequest{Address: s.address.String(), Denom: fiveLiquid1.Denom}) + Expect(err).To(BeNil()) + Expect(daoOwnerAddressLiquidBalanceAfterFund.Balance.String()).To(Equal(fiveLiquid1.String())) + + daoNewOwnerAddressAllBalancesAfterFund, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: newOwnerAddr.String()}) + Expect(err).To(BeNil()) + Expect(daoNewOwnerAddressAllBalancesAfterFund.Balances.IsZero()).To(BeFalse()) + okNewAcc, islmNewAccAmount := daoNewOwnerAddressAllBalancesAfterFund.Balances.Find(twoIslm.Denom) + Expect(okNewAcc).To(BeTrue()) + Expect(islmNewAccAmount.String()).To(Equal(twoIslm.String())) + + // Transfer TX Process + transferOwnershipMsg = types.NewMsgTransferOwnership(s.address, newOwnerAddr) + _, err = testutil.DeliverTx(s.ctx, s.app, s.priv, &gasPrice, transferOwnershipMsg) + Expect(err).To(BeNil(), "transaction should succeed") + s.Commit() + + // Checks after transfer ownership + // Module bank balance shouldn't change + daoModuleAddressBankBalanceAfterTransferIslm := s.app.BankKeeper.GetBalance(s.ctx, daoModuleAcc.GetAddress(), oneIslm.Denom) + Expect(daoModuleAddressBankBalanceAfterTransferIslm.Amount.String()).To(Equal(daoModuleAddressBankBalanceAfterFundIslm.Amount.String())) + daoModuleAddressBankBalanceAfterTransferLiquid := s.app.BankKeeper.GetBalance(s.ctx, daoModuleAcc.GetAddress(), fiveLiquid1.Denom) + Expect(daoModuleAddressBankBalanceAfterTransferLiquid.Amount.String()).To(Equal(daoModuleAddressBankBalanceAfterFundLiquid.Amount.String())) + + // Module internal total balance shouldn't change + daoTotalBalanceAfterTransfer, err := s.queryClient.TotalBalance(s.ctx, &types.QueryTotalBalanceRequest{}) + Expect(err).To(BeNil()) + Expect(daoTotalBalanceAfterTransfer.TotalBalance.IsZero()).To(BeFalse()) + ok, islmAmountAfterTransfer := daoTotalBalanceAfterTransfer.TotalBalance.Find(oneIslm.Denom) + Expect(ok).To(BeTrue()) + Expect(islmAmountAfterTransfer.String()).To(Equal(islmAmountAfterFund.String())) + ok, liquidAmountAfterTransfer := daoTotalBalanceAfterTransfer.TotalBalance.Find(fiveLiquid1.Denom) + Expect(ok).To(BeTrue()) + Expect(liquidAmountAfterTransfer.String()).To(Equal(liquidAmountAfterFund.String())) + + // Old owner internal dao balance should become empty + daoOwnerAddressAllBalancesAfterTransfer, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: s.address.String()}) + Expect(err).To(BeNil()) + Expect(daoOwnerAddressAllBalancesAfterTransfer.Balances.IsZero()).To(BeTrue()) + + // All tokens should be transferred to new owner + daoNewOwnerAddressAllBalancesAfterTransfer, err := s.queryClient.AllBalances(s.ctx, &types.QueryAllBalancesRequest{Address: newOwnerAddr.String()}) + Expect(err).To(BeNil()) + Expect(daoNewOwnerAddressAllBalancesAfterTransfer.Balances.IsZero()).To(BeFalse()) + okNewAcc, islmNewAccAmount = daoNewOwnerAddressAllBalancesAfterTransfer.Balances.Find(oneIslm.Denom) + Expect(okNewAcc).To(BeTrue()) + Expect(islmNewAccAmount.String()).To(Equal(oneIslm.Add(twoIslm).String())) + okNewAcc, liquidNewAccAmount := daoNewOwnerAddressAllBalancesAfterTransfer.Balances.Find(fiveLiquid1.Denom) + Expect(okNewAcc).To(BeTrue()) + Expect(liquidNewAccAmount.String()).To(Equal(fiveLiquid1.String())) + daoNewOwnerAddressIslmBalanceAfterTransfer, err := s.queryClient.Balance(s.ctx, &types.QueryBalanceRequest{Address: newOwnerAddr.String(), Denom: oneIslm.Denom}) + Expect(err).To(BeNil()) + Expect(daoNewOwnerAddressIslmBalanceAfterTransfer.Balance.String()).To(Equal(oneIslm.Add(twoIslm).String())) + daoNewOwnerAddressLiquidBalanceAfterTransfer, err := s.queryClient.Balance(s.ctx, &types.QueryBalanceRequest{Address: newOwnerAddr.String(), Denom: fiveLiquid1.Denom}) + Expect(err).To(BeNil()) + Expect(daoNewOwnerAddressLiquidBalanceAfterTransfer.Balance.String()).To(Equal(fiveLiquid1.String())) + }) + }) + }) })