Mukan Erkin Törük
88dd97a9f8
Some checks failed
CodeQL / Analyze (push) Waiting to run
golangci-lint / lint (push) Waiting to run
Tests / Code Coverage / build (amd64) (push) Waiting to run
Tests / Code Coverage / build (arm64) (push) Waiting to run
Tests / Code Coverage / unit-tests (map[additional-args:-tags="test_e2e" name:e2e path:./e2e]) (push) Waiting to run
Tests / Code Coverage / unit-tests (map[name:08-wasm path:./modules/light-clients/08-wasm]) (push) Waiting to run
Tests / Code Coverage / unit-tests (map[name:ibc-go path:.]) (push) Waiting to run
Docker Build & Push Simapp (main) / docker-build (push) Has been cancelled
542 lines
19 KiB
Go
542 lines
19 KiB
Go
//go:build !test_e2e
|
|
|
|
package interchainaccounts
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/cosmos/gogoproto/proto"
|
|
"github.com/cosmos/interchaintest/v10"
|
|
"github.com/cosmos/interchaintest/v10/ibc"
|
|
test "github.com/cosmos/interchaintest/v10/testutil"
|
|
testifysuite "github.com/stretchr/testify/suite"
|
|
|
|
sdkmath "cosmossdk.io/math"
|
|
|
|
sdk "git.cw.tr/mukan-network/mukan-sdk/types"
|
|
banktypes "git.cw.tr/mukan-network/mukan-sdk/x/bank/types"
|
|
govtypes "git.cw.tr/mukan-network/mukan-sdk/x/gov/types"
|
|
govv1 "git.cw.tr/mukan-network/mukan-sdk/x/gov/types/v1"
|
|
|
|
"github.com/cosmos/ibc-go/e2e/testsuite"
|
|
"github.com/cosmos/ibc-go/e2e/testsuite/query"
|
|
"github.com/cosmos/ibc-go/e2e/testvalues"
|
|
controllertypes "git.cw.tr/mukan-network/mukan-ibc/modules/apps/27-interchain-accounts/controller/types"
|
|
icatypes "git.cw.tr/mukan-network/mukan-ibc/modules/apps/27-interchain-accounts/types"
|
|
channeltypes "git.cw.tr/mukan-network/mukan-ibc/modules/core/04-channel/types"
|
|
ibctesting "git.cw.tr/mukan-network/mukan-ibc/testing"
|
|
)
|
|
|
|
// orderMapping is a mapping from channel ordering to the string representation of the ordering.
|
|
// the representation can be different depending on the relayer implementation.
|
|
var orderMapping = map[channeltypes.Order][]string{
|
|
channeltypes.ORDERED: {channeltypes.ORDERED.String(), "Ordered"},
|
|
channeltypes.UNORDERED: {channeltypes.UNORDERED.String(), "Unordered"},
|
|
}
|
|
|
|
// compatibility:from_version: v7.10.0
|
|
func TestInterchainAccountsTestSuite(t *testing.T) {
|
|
testifysuite.Run(t, new(InterchainAccountsTestSuite))
|
|
}
|
|
|
|
type InterchainAccountsTestSuite struct {
|
|
testsuite.E2ETestSuite
|
|
}
|
|
|
|
// SetupSuite sets up chains for the current test suite
|
|
func (s *InterchainAccountsTestSuite) SetupSuite() {
|
|
s.SetupChains(context.TODO(), 2, nil)
|
|
}
|
|
|
|
// RegisterInterchainAccount will attempt to register an interchain account on the counterparty chain.
|
|
func (s *InterchainAccountsTestSuite) RegisterInterchainAccount(ctx context.Context, chain ibc.Chain, user ibc.Wallet, msgRegisterAccount *controllertypes.MsgRegisterInterchainAccount) {
|
|
txResp := s.BroadcastMessages(ctx, chain, user, msgRegisterAccount)
|
|
s.AssertTxSuccess(txResp)
|
|
}
|
|
|
|
func (s *InterchainAccountsTestSuite) TestMsgSendTx_SuccessfulTransfer() {
|
|
s.testMsgSendTxSuccessfulTransfer(channeltypes.ORDERED)
|
|
}
|
|
|
|
// compatibility:TestMsgSendTx_SuccessfulTransfer_UnorderedChannel:from_versions: v7.10.0,v8.7.0,v10.0.0
|
|
func (s *InterchainAccountsTestSuite) TestMsgSendTx_SuccessfulTransfer_UnorderedChannel() {
|
|
s.testMsgSendTxSuccessfulTransfer(channeltypes.UNORDERED)
|
|
}
|
|
|
|
func (s *InterchainAccountsTestSuite) testMsgSendTxSuccessfulTransfer(order channeltypes.Order) {
|
|
t := s.T()
|
|
ctx := context.TODO()
|
|
|
|
testName := t.Name()
|
|
relayer := s.CreateDefaultPaths(testName)
|
|
|
|
chainA, chainB := s.GetChains()
|
|
|
|
// setup 2 accounts: controller account on chain A, a second chain B account.
|
|
// host account will be created when the ICA is registered
|
|
controllerAccount := s.CreateUserOnChainA(ctx, testvalues.StartingTokenAmount)
|
|
controllerAddress := controllerAccount.FormattedAddress()
|
|
chainBAccount := s.CreateUserOnChainB(ctx, testvalues.StartingTokenAmount)
|
|
var hostAccount string
|
|
|
|
t.Run("broadcast MsgRegisterInterchainAccount", func(t *testing.T) {
|
|
// explicitly set the version string because we don't want to use incentivized channels.
|
|
version := icatypes.NewDefaultMetadataString(ibctesting.FirstConnectionID, ibctesting.FirstConnectionID)
|
|
msgRegisterAccount := controllertypes.NewMsgRegisterInterchainAccount(ibctesting.FirstConnectionID, controllerAddress, version, order)
|
|
|
|
txResp := s.BroadcastMessages(ctx, chainA, controllerAccount, msgRegisterAccount)
|
|
s.AssertTxSuccess(txResp)
|
|
})
|
|
|
|
t.Run("start relayer", func(t *testing.T) {
|
|
s.StartRelayer(relayer, testName)
|
|
})
|
|
|
|
t.Run("verify interchain account", func(t *testing.T) {
|
|
var err error
|
|
hostAccount, err = query.InterchainAccount(ctx, chainA, controllerAddress, ibctesting.FirstConnectionID)
|
|
s.Require().NoError(err)
|
|
s.Require().NotEmpty(hostAccount)
|
|
|
|
channels, err := relayer.GetChannels(ctx, s.GetRelayerExecReporter(), chainA.Config().ChainID)
|
|
s.Require().NoError(err)
|
|
s.Require().Equal(len(channels), 2)
|
|
icaChannel := channels[0]
|
|
|
|
s.Require().Contains(orderMapping[order], icaChannel.Ordering)
|
|
})
|
|
|
|
t.Run("interchain account executes a bank transfer on behalf of the corresponding owner account", func(t *testing.T) {
|
|
t.Run("fund interchain account wallet", func(t *testing.T) {
|
|
// fund the host account so it has some $$ to send
|
|
err := chainB.SendFunds(ctx, interchaintest.FaucetAccountKeyName, ibc.WalletAmount{
|
|
Address: hostAccount,
|
|
Amount: sdkmath.NewInt(testvalues.StartingTokenAmount),
|
|
Denom: chainB.Config().Denom,
|
|
})
|
|
s.Require().NoError(err)
|
|
})
|
|
|
|
t.Run("broadcast MsgSendTx", func(t *testing.T) {
|
|
// assemble bank transfer message from host account to user account on host chain
|
|
msgSend := &banktypes.MsgSend{
|
|
FromAddress: hostAccount,
|
|
ToAddress: chainBAccount.FormattedAddress(),
|
|
Amount: sdk.NewCoins(testvalues.DefaultTransferAmount(chainB.Config().Denom)),
|
|
}
|
|
|
|
cdc := testsuite.Codec()
|
|
bz, err := icatypes.SerializeCosmosTx(cdc, []proto.Message{msgSend}, icatypes.EncodingProtobuf)
|
|
s.Require().NoError(err)
|
|
|
|
packetData := icatypes.InterchainAccountPacketData{
|
|
Type: icatypes.EXECUTE_TX,
|
|
Data: bz,
|
|
Memo: "e2e",
|
|
}
|
|
|
|
msgSendTx := controllertypes.NewMsgSendTx(controllerAddress, ibctesting.FirstConnectionID, uint64(time.Hour.Nanoseconds()), packetData)
|
|
|
|
resp := s.BroadcastMessages(
|
|
ctx,
|
|
chainA,
|
|
controllerAccount,
|
|
msgSendTx,
|
|
)
|
|
|
|
s.AssertTxSuccess(resp)
|
|
|
|
s.Require().NoError(test.WaitForBlocks(ctx, 10, chainA, chainB))
|
|
})
|
|
|
|
t.Run("verify tokens transferred", func(t *testing.T) {
|
|
balance, err := query.Balance(ctx, chainB, chainBAccount.FormattedAddress(), chainB.Config().Denom)
|
|
s.Require().NoError(err)
|
|
|
|
_, err = query.Balance(ctx, chainB, hostAccount, chainB.Config().Denom)
|
|
s.Require().NoError(err)
|
|
|
|
expected := testvalues.IBCTransferAmount + testvalues.StartingTokenAmount
|
|
s.Require().Equal(expected, balance.Int64())
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *InterchainAccountsTestSuite) TestMsgSendTx_FailedTransfer_InsufficientFunds() {
|
|
t := s.T()
|
|
ctx := context.TODO()
|
|
|
|
testName := t.Name()
|
|
relayer := s.CreateDefaultPaths(testName)
|
|
|
|
chainA, chainB := s.GetChains()
|
|
|
|
// setup 2 accounts: controller account on chain A, a second chain B account.
|
|
// host account will be created when the ICA is registered
|
|
controllerAccount := s.CreateUserOnChainA(ctx, testvalues.StartingTokenAmount)
|
|
controllerAddress := controllerAccount.FormattedAddress()
|
|
chainBAccount := s.CreateUserOnChainB(ctx, testvalues.StartingTokenAmount)
|
|
var hostAccount string
|
|
|
|
t.Run("broadcast MsgRegisterInterchainAccount", func(t *testing.T) {
|
|
// explicitly set the version string because we don't want to use incentivized channels.
|
|
version := icatypes.NewDefaultMetadataString(ibctesting.FirstConnectionID, ibctesting.FirstConnectionID)
|
|
msgRegisterAccount := controllertypes.NewMsgRegisterInterchainAccount(ibctesting.FirstConnectionID, controllerAddress, version, channeltypes.ORDERED)
|
|
|
|
txResp := s.BroadcastMessages(ctx, chainA, controllerAccount, msgRegisterAccount)
|
|
s.AssertTxSuccess(txResp)
|
|
})
|
|
|
|
t.Run("start relayer", func(t *testing.T) {
|
|
s.StartRelayer(relayer, testName)
|
|
})
|
|
|
|
t.Run("verify interchain account", func(t *testing.T) {
|
|
var err error
|
|
hostAccount, err = query.InterchainAccount(ctx, chainA, controllerAddress, ibctesting.FirstConnectionID)
|
|
s.Require().NoError(err)
|
|
s.Require().NotEmpty(hostAccount)
|
|
|
|
channels, err := relayer.GetChannels(ctx, s.GetRelayerExecReporter(), chainA.Config().ChainID)
|
|
s.Require().NoError(err)
|
|
s.Require().Equal(len(channels), 2)
|
|
})
|
|
|
|
t.Run("fail to execute bank transfer over ICA", func(t *testing.T) {
|
|
t.Run("verify empty host wallet", func(t *testing.T) {
|
|
hostAccountBalance, err := query.Balance(ctx, chainB, hostAccount, chainB.Config().Denom)
|
|
|
|
s.Require().NoError(err)
|
|
s.Require().Zero(hostAccountBalance.Int64())
|
|
})
|
|
|
|
t.Run("broadcast MsgSendTx", func(t *testing.T) {
|
|
// assemble bank transfer message from host account to user account on host chain
|
|
msgSend := &banktypes.MsgSend{
|
|
FromAddress: hostAccount,
|
|
ToAddress: chainBAccount.FormattedAddress(),
|
|
Amount: sdk.NewCoins(testvalues.DefaultTransferAmount(chainB.Config().Denom)),
|
|
}
|
|
|
|
cdc := testsuite.Codec()
|
|
bz, err := icatypes.SerializeCosmosTx(cdc, []proto.Message{msgSend}, icatypes.EncodingProtobuf)
|
|
s.Require().NoError(err)
|
|
|
|
packetData := icatypes.InterchainAccountPacketData{
|
|
Type: icatypes.EXECUTE_TX,
|
|
Data: bz,
|
|
Memo: "e2e",
|
|
}
|
|
|
|
msgSendTx := controllertypes.NewMsgSendTx(controllerAddress, ibctesting.FirstConnectionID, uint64(time.Hour.Nanoseconds()), packetData)
|
|
|
|
txResp := s.BroadcastMessages(
|
|
ctx,
|
|
chainA,
|
|
controllerAccount,
|
|
msgSendTx,
|
|
)
|
|
|
|
s.AssertTxSuccess(txResp)
|
|
|
|
s.Require().NoError(test.WaitForBlocks(ctx, 10, chainA, chainB))
|
|
})
|
|
|
|
t.Run("verify balance is the same", func(t *testing.T) {
|
|
balance, err := query.Balance(ctx, chainB, chainBAccount.FormattedAddress(), chainB.Config().Denom)
|
|
s.Require().NoError(err)
|
|
|
|
expected := testvalues.StartingTokenAmount
|
|
s.Require().Equal(expected, balance.Int64())
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *InterchainAccountsTestSuite) TestMsgSendTx_SuccessfulTransfer_AfterReopeningICA() {
|
|
t := s.T()
|
|
ctx := context.TODO()
|
|
|
|
testName := t.Name()
|
|
relayer := s.CreateDefaultPaths(testName)
|
|
|
|
chainA, chainB := s.GetChains()
|
|
|
|
// setup 2 accounts: controller account on chain A, a second chain B account.
|
|
// host account will be created when the ICA is registered
|
|
controllerAccount := s.CreateUserOnChainA(ctx, testvalues.StartingTokenAmount)
|
|
controllerAddress := controllerAccount.FormattedAddress()
|
|
chainBAccount := s.CreateUserOnChainB(ctx, testvalues.StartingTokenAmount)
|
|
|
|
var (
|
|
portID string
|
|
hostAccount string
|
|
|
|
initialChannelID = "channel-1"
|
|
channelIDAfterReopening = "channel-2"
|
|
)
|
|
|
|
t.Run("register interchain account", func(t *testing.T) {
|
|
var err error
|
|
// explicitly set the version string because we don't want to use incentivized channels.
|
|
version := icatypes.NewDefaultMetadataString(ibctesting.FirstConnectionID, ibctesting.FirstConnectionID)
|
|
msgRegisterInterchainAccount := controllertypes.NewMsgRegisterInterchainAccount(ibctesting.FirstConnectionID, controllerAddress, version, channeltypes.ORDERED)
|
|
s.RegisterInterchainAccount(ctx, chainA, controllerAccount, msgRegisterInterchainAccount)
|
|
portID, err = icatypes.NewControllerPortID(controllerAddress)
|
|
s.Require().NoError(err)
|
|
})
|
|
|
|
t.Run("start relayer", func(t *testing.T) {
|
|
s.StartRelayer(relayer, testName)
|
|
})
|
|
|
|
t.Run("verify interchain account", func(t *testing.T) {
|
|
var err error
|
|
hostAccount, err = query.InterchainAccount(ctx, chainA, controllerAddress, ibctesting.FirstConnectionID)
|
|
s.Require().NoError(err)
|
|
s.Require().NotEmpty(hostAccount)
|
|
|
|
_, err = query.Channel(ctx, chainA, portID, initialChannelID)
|
|
s.Require().NoError(err)
|
|
})
|
|
|
|
// stop the relayer to let the submit tx message time out
|
|
t.Run("stop relayer", func(t *testing.T) {
|
|
s.StopRelayer(ctx, relayer)
|
|
})
|
|
|
|
t.Run("submit tx message with bank transfer message times out", func(t *testing.T) {
|
|
t.Run("fund interchain account wallet", func(t *testing.T) {
|
|
// fund the host account so it has some $$ to send
|
|
err := chainB.SendFunds(ctx, interchaintest.FaucetAccountKeyName, ibc.WalletAmount{
|
|
Address: hostAccount,
|
|
Amount: sdkmath.NewInt(testvalues.StartingTokenAmount),
|
|
Denom: chainB.Config().Denom,
|
|
})
|
|
s.Require().NoError(err)
|
|
})
|
|
|
|
t.Run("broadcast MsgSendTx", func(t *testing.T) {
|
|
// assemble bank transfer message from host account to user account on host chain
|
|
msgSend := &banktypes.MsgSend{
|
|
FromAddress: hostAccount,
|
|
ToAddress: chainBAccount.FormattedAddress(),
|
|
Amount: sdk.NewCoins(testvalues.DefaultTransferAmount(chainB.Config().Denom)),
|
|
}
|
|
|
|
cdc := testsuite.Codec()
|
|
|
|
bz, err := icatypes.SerializeCosmosTx(cdc, []proto.Message{msgSend}, icatypes.EncodingProtobuf)
|
|
s.Require().NoError(err)
|
|
|
|
packetData := icatypes.InterchainAccountPacketData{
|
|
Type: icatypes.EXECUTE_TX,
|
|
Data: bz,
|
|
Memo: "e2e",
|
|
}
|
|
|
|
msgSendTx := controllertypes.NewMsgSendTx(controllerAddress, ibctesting.FirstConnectionID, uint64(1), packetData)
|
|
|
|
resp := s.BroadcastMessages(
|
|
ctx,
|
|
chainA,
|
|
controllerAccount,
|
|
msgSendTx,
|
|
)
|
|
|
|
s.AssertTxSuccess(resp)
|
|
|
|
// this sleep is to allow the packet to timeout
|
|
time.Sleep(1 * time.Second)
|
|
})
|
|
})
|
|
|
|
t.Run("start relayer", func(t *testing.T) {
|
|
s.StartRelayer(relayer, testName)
|
|
})
|
|
|
|
t.Run("verify channel is closed due to timeout on ordered channel", func(t *testing.T) {
|
|
channel, err := query.Channel(ctx, chainA, portID, initialChannelID)
|
|
s.Require().NoError(err)
|
|
|
|
s.Require().Equal(channeltypes.CLOSED, channel.State, "the channel was not in an expected state")
|
|
})
|
|
|
|
t.Run("verify tokens not transferred", func(t *testing.T) {
|
|
balance, err := query.Balance(ctx, chainB, chainBAccount.FormattedAddress(), chainB.Config().Denom)
|
|
s.Require().NoError(err)
|
|
|
|
_, err = query.Balance(ctx, chainB, hostAccount, chainB.Config().Denom)
|
|
s.Require().NoError(err)
|
|
|
|
expected := testvalues.StartingTokenAmount
|
|
s.Require().Equal(expected, balance.Int64())
|
|
})
|
|
|
|
// re-register interchain account to reopen the channel now that it has been closed due to timeout
|
|
// on an ordered channel
|
|
t.Run("register interchain account", func(t *testing.T) {
|
|
// explicitly set the version string because we don't want to use incentivized channels.
|
|
version := icatypes.NewDefaultMetadataString(ibctesting.FirstConnectionID, ibctesting.FirstConnectionID)
|
|
msgRegisterInterchainAccount := controllertypes.NewMsgRegisterInterchainAccount(ibctesting.FirstConnectionID, controllerAddress, version, channeltypes.ORDERED)
|
|
s.RegisterInterchainAccount(ctx, chainA, controllerAccount, msgRegisterInterchainAccount)
|
|
|
|
s.Require().NoError(test.WaitForBlocks(ctx, 10, chainA, chainB))
|
|
})
|
|
|
|
t.Run("verify new channel is now open and interchain account has been reregistered with the same portID", func(t *testing.T) {
|
|
channel, err := query.Channel(ctx, chainA, portID, channelIDAfterReopening)
|
|
s.Require().NoError(err)
|
|
|
|
s.Require().Equal(channeltypes.OPEN, channel.State, "the channel was not in an expected state")
|
|
})
|
|
|
|
t.Run("broadcast MsgSendTx", func(t *testing.T) {
|
|
// assemble bank transfer message from host account to user account on host chain
|
|
msgSend := &banktypes.MsgSend{
|
|
FromAddress: hostAccount,
|
|
ToAddress: chainBAccount.FormattedAddress(),
|
|
Amount: sdk.NewCoins(testvalues.DefaultTransferAmount(chainB.Config().Denom)),
|
|
}
|
|
|
|
cdc := testsuite.Codec()
|
|
|
|
bz, err := icatypes.SerializeCosmosTx(cdc, []proto.Message{msgSend}, icatypes.EncodingProtobuf)
|
|
s.Require().NoError(err)
|
|
|
|
packetData := icatypes.InterchainAccountPacketData{
|
|
Type: icatypes.EXECUTE_TX,
|
|
Data: bz,
|
|
Memo: "e2e",
|
|
}
|
|
|
|
msgSendTx := controllertypes.NewMsgSendTx(controllerAddress, ibctesting.FirstConnectionID, uint64(5*time.Minute), packetData)
|
|
|
|
resp := s.BroadcastMessages(
|
|
ctx,
|
|
chainA,
|
|
controllerAccount,
|
|
msgSendTx,
|
|
)
|
|
|
|
s.AssertTxSuccess(resp)
|
|
|
|
// time for the packet to be relayed
|
|
s.Require().NoError(test.WaitForBlocks(ctx, 5, chainA, chainB))
|
|
})
|
|
|
|
t.Run("verify tokens transferred", func(t *testing.T) {
|
|
balance, err := query.Balance(ctx, chainB, chainBAccount.FormattedAddress(), chainB.Config().Denom)
|
|
s.Require().NoError(err)
|
|
|
|
expected := testvalues.IBCTransferAmount + testvalues.StartingTokenAmount
|
|
s.Require().Equal(expected, balance.Int64())
|
|
})
|
|
}
|
|
|
|
func (s *InterchainAccountsTestSuite) TestMsgSendTx_SuccessfulSubmitGovProposal_OrderedChannel() {
|
|
s.testMsgSendTxSuccessfulGovProposal(channeltypes.ORDERED)
|
|
}
|
|
|
|
// compatibility:TestMsgSendTx_SuccessfulSubmitGovProposal_UnorderedChannel:from_versions: v7.10.0,v8.7.0,v10.0.0
|
|
func (s *InterchainAccountsTestSuite) TestMsgSendTx_SuccessfulSubmitGovProposal_UnorderedChannel() {
|
|
s.testMsgSendTxSuccessfulGovProposal(channeltypes.UNORDERED)
|
|
}
|
|
|
|
func (s *InterchainAccountsTestSuite) testMsgSendTxSuccessfulGovProposal(order channeltypes.Order) {
|
|
t := s.T()
|
|
ctx := context.TODO()
|
|
|
|
testName := t.Name()
|
|
relayer := s.CreateDefaultPaths(testName)
|
|
|
|
chainA, chainB := s.GetChains()
|
|
|
|
// setup 2 accounts: controller account on chain A, a second chain B account.
|
|
// host account will be created when the ICA is registered
|
|
controllerAccount := s.CreateUserOnChainA(ctx, testvalues.StartingTokenAmount)
|
|
controllerAddress := controllerAccount.FormattedAddress()
|
|
var hostAccount string
|
|
|
|
t.Run("broadcast MsgRegisterInterchainAccount", func(t *testing.T) {
|
|
// explicitly set the version string because we don't want to use incentivized channels.
|
|
version := icatypes.NewDefaultMetadataString(ibctesting.FirstConnectionID, ibctesting.FirstConnectionID)
|
|
msgRegisterAccount := controllertypes.NewMsgRegisterInterchainAccount(ibctesting.FirstConnectionID, controllerAddress, version, order)
|
|
|
|
txResp := s.BroadcastMessages(ctx, chainA, controllerAccount, msgRegisterAccount)
|
|
s.AssertTxSuccess(txResp)
|
|
})
|
|
|
|
t.Run("start relayer", func(t *testing.T) {
|
|
s.StartRelayer(relayer, testName)
|
|
})
|
|
|
|
t.Run("verify interchain account", func(t *testing.T) {
|
|
var err error
|
|
hostAccount, err = query.InterchainAccount(ctx, chainA, controllerAddress, ibctesting.FirstConnectionID)
|
|
s.Require().NoError(err)
|
|
s.Require().NotEmpty(hostAccount)
|
|
|
|
channels, err := relayer.GetChannels(ctx, s.GetRelayerExecReporter(), chainA.Config().ChainID)
|
|
s.Require().NoError(err)
|
|
s.Require().Equal(len(channels), 2)
|
|
icaChannel := channels[0]
|
|
|
|
s.Require().Contains(orderMapping[order], icaChannel.Ordering)
|
|
})
|
|
|
|
t.Run("interchain account submits a governance proposal on behalf of the corresponding owner account", func(t *testing.T) {
|
|
t.Run("fund interchain account wallet", func(t *testing.T) {
|
|
// fund the host account so it has some $$ to send
|
|
err := chainB.SendFunds(ctx, interchaintest.FaucetAccountKeyName, ibc.WalletAmount{
|
|
Address: hostAccount,
|
|
Amount: sdkmath.NewInt(testvalues.StartingTokenAmount),
|
|
Denom: chainB.Config().Denom,
|
|
})
|
|
s.Require().NoError(err)
|
|
})
|
|
|
|
t.Run("broadcast MsgSendTx for MsgSubmitProposal", func(t *testing.T) {
|
|
govModuleAddress, err := query.ModuleAccountAddress(ctx, govtypes.ModuleName, chainB)
|
|
s.Require().NoError(err)
|
|
s.Require().NotNil(govModuleAddress)
|
|
|
|
msg, err := govv1.NewMsgSubmitProposal(
|
|
[]sdk.Msg{},
|
|
sdk.NewCoins(sdk.NewCoin(chainB.Config().Denom, sdkmath.NewInt(10_000_000))),
|
|
hostAccount, "e2e", "e2e", "e2e", false,
|
|
)
|
|
s.Require().NoError(err)
|
|
|
|
cdc := testsuite.Codec()
|
|
bz, err := icatypes.SerializeCosmosTx(cdc, []proto.Message{msg}, icatypes.EncodingProtobuf)
|
|
s.Require().NoError(err)
|
|
|
|
packetData := icatypes.InterchainAccountPacketData{
|
|
Type: icatypes.EXECUTE_TX,
|
|
Data: bz,
|
|
Memo: "e2e",
|
|
}
|
|
|
|
msgSendTx := controllertypes.NewMsgSendTx(controllerAddress, ibctesting.FirstConnectionID, uint64(time.Hour.Nanoseconds()), packetData)
|
|
resp := s.BroadcastMessages(
|
|
ctx,
|
|
chainA,
|
|
controllerAccount,
|
|
msgSendTx,
|
|
)
|
|
|
|
s.AssertTxSuccess(resp)
|
|
|
|
s.Require().NoError(test.WaitForBlocks(ctx, 10, chainA, chainB))
|
|
})
|
|
|
|
t.Run("verify proposal included", func(t *testing.T) {
|
|
proposalResp, err := query.GRPCQuery[govv1.QueryProposalResponse](ctx, chainB, &govv1.QueryProposalRequest{ProposalId: 1})
|
|
s.Require().NoError(err)
|
|
|
|
s.Require().Equal("e2e", proposalResp.Proposal.Title)
|
|
})
|
|
})
|
|
}
|