feat!: native core SDK command support

chain/cosmos/cosmos_chain.go

@@ -22,10 +22,8 @@ import (
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 	"github.com/cosmos/cosmos-sdk/types"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
-	bankTypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 	paramsutils "github.com/cosmos/cosmos-sdk/x/params/client/utils"
-	cosmosproto "github.com/cosmos/gogoproto/proto"
 	chanTypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
 	dockertypes "github.com/docker/docker/api/types"
 	volumetypes "github.com/docker/docker/api/types/volume"
@@ -38,8 +36,6 @@ import (
 	"github.com/strangelove-ventures/interchaintest/v8/testutil"
 	"go.uber.org/zap"
 	"golang.org/x/sync/errgroup"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
 )
 
 // CosmosChain is a local docker testnet for a Cosmos SDK chain.
@@ -55,6 +51,7 @@ type CosmosChain struct {
 	// Additional processes that need to be run on a per-chain basis.
 	Sidecars SidecarProcesses
 
+	cdc      *codec.ProtoCodec
 	log      *zap.Logger
 	keyring  keyring.Keyring
 	findTxMu sync.Mutex
@@ -104,10 +101,16 @@ func NewCosmosChain(testName string, chainConfig ibc.ChainConfig, numValidators
 		numValidators: numValidators,
 		numFullNodes:  numFullNodes,
 		log:           log,
+		cdc:           cdc,
 		keyring:       kr,
 	}
 }
 
+// GetCodec returns the codec for the chain.
+func (c *CosmosChain) GetCodec() *codec.ProtoCodec {
+	return c.cdc
+}
+
 // Nodes returns all nodes, including validators and fullnodes.
 func (c *CosmosChain) Nodes() ChainNodes {
 	return append(c.Validators, c.FullNodes...)
@@ -313,7 +316,7 @@ func (c *CosmosChain) BuildRelayerWallet(ctx context.Context, keyName string) (i
 
 // Implements Chain interface
 func (c *CosmosChain) SendFunds(ctx context.Context, keyName string, amount ibc.WalletAmount) error {
-	return c.getFullNode().SendFunds(ctx, keyName, amount)
+	return c.getFullNode().BankSend(ctx, keyName, amount)
 }
 
 // Implements Chain interface
@@ -375,24 +378,32 @@ func (c *CosmosChain) SendIBCTransfer(
 	return tx, nil
 }
 
+// ExecQueryToResponse is a helper to convert a query to its response.
+func (c *CosmosChain) ExecQueryToResponse(ctx context.Context, chain *CosmosChain, cmd []string, res interface{}) error {
+	rCmd := make([]string, 0)
+	for _, c := range cmd {
+		if c != "" {
+			rCmd = append(rCmd, c)
+		}
+	}
+
+	stdout, stderr, err := chain.getFullNode().ExecQuery(ctx, rCmd...)
+	if err != nil {
+		fmt.Println("HandleQuery err: ", string(stdout), string(stderr), err.Error())
+		return err
+	}
+
+	return json.Unmarshal(stdout, &res)
+}
+
 // GetGovernanceAddress performs a query to get the address of the chain's x/gov module
 func (c *CosmosChain) GetGovernanceAddress(ctx context.Context) (string, error) {
 	return c.GetModuleAddress(ctx, govtypes.ModuleName)
 }
 
 // GetModuleAddress performs a query to get the address of the specified chain module
 func (c *CosmosChain) GetModuleAddress(ctx context.Context, moduleName string) (string, error) {
-	return c.getFullNode().GetModuleAddress(ctx, moduleName)
-}
-
-// QueryProposal returns the state and details of a governance proposal.
-func (c *CosmosChain) QueryProposal(ctx context.Context, proposalID string) (*ProposalResponse, error) {
-	return c.getFullNode().QueryProposal(ctx, proposalID)
-}
-
-// QueryProposal returns the state and details of an IBC-Go v8 / SDK v50 governance proposal.
-func (c *CosmosChain) QueryProposalV8(ctx context.Context, proposalID string) (*ProposalResponseV8, error) {
-	return c.getFullNode().QueryProposalV8(ctx, proposalID)
+	return c.AuthGetModuleAddress(ctx, moduleName)
 }
 
 // PushNewWasmClientProposal submits a new wasm client governance proposal to the chain
@@ -443,38 +454,6 @@ func (c *CosmosChain) SubmitProposal(ctx context.Context, keyName string, prop T
 	return c.txProposal(txHash)
 }
 
-// Build a gov v1 proposal type.
-//
-// The proposer field should only be set for IBC-Go v8 / SDK v50 chains.
-func (c *CosmosChain) BuildProposal(messages []cosmosproto.Message, title, summary, metadata, depositStr, proposer string, expedited bool) (TxProposalv1, error) {
-	var propType TxProposalv1
-	rawMsgs := make([]json.RawMessage, len(messages))
-
-	for i, msg := range messages {
-		msg, err := c.Config().EncodingConfig.Codec.MarshalInterfaceJSON(msg)
-		if err != nil {
-			return propType, err
-		}
-		rawMsgs[i] = msg
-	}
-
-	propType = TxProposalv1{
-		Messages: rawMsgs,
-		Metadata: metadata,
-		Deposit:  depositStr,
-		Title:    title,
-		Summary:  summary,
-	}
-
-	// SDK v50 only
-	if proposer != "" {
-		propType.Proposer = proposer
-		propType.Expedited = expedited
-	}
-
-	return propType, nil
-}
-
 // TextProposal submits a text governance proposal to the chain.
 func (c *CosmosChain) TextProposal(ctx context.Context, keyName string, prop TextProposal) (tx TxProposal, _ error) {
 	txHash, err := c.getFullNode().TextProposal(ctx, keyName, prop)
@@ -565,47 +544,6 @@ func (c *CosmosChain) ExportState(ctx context.Context, height int64) (string, er
 	return c.getFullNode().ExportState(ctx, height)
 }
 
-// GetBalance fetches the current balance for a specific account address and denom.
-// Implements Chain interface
-func (c *CosmosChain) GetBalance(ctx context.Context, address string, denom string) (sdkmath.Int, error) {
-	params := &bankTypes.QueryBalanceRequest{Address: address, Denom: denom}
-	grpcAddress := c.getFullNode().hostGRPCPort
-	conn, err := grpc.Dial(grpcAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
-	if err != nil {
-		return sdkmath.Int{}, err
-	}
-	defer conn.Close()
-
-	queryClient := bankTypes.NewQueryClient(conn)
-	res, err := queryClient.Balance(ctx, params)
-
-	if err != nil {
-		return sdkmath.Int{}, err
-	}
-
-	return res.Balance.Amount, nil
-}
-
-// AllBalances fetches an account address's balance for all denoms it holds
-func (c *CosmosChain) AllBalances(ctx context.Context, address string) (types.Coins, error) {
-	params := bankTypes.QueryAllBalancesRequest{Address: address}
-	grpcAddress := c.getFullNode().hostGRPCPort
-	conn, err := grpc.Dial(grpcAddress, grpc.WithTransportCredentials(insecure.NewCredentials()))
-	if err != nil {
-		return nil, err
-	}
-	defer conn.Close()
-
-	queryClient := bankTypes.NewQueryClient(conn)
-	res, err := queryClient.AllBalances(ctx, &params)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return res.GetBalances(), nil
-}
-
 func (c *CosmosChain) GetTransaction(txhash string) (*types.TxResponse, error) {
 	fn := c.getFullNode()
 	return fn.GetTransaction(fn.CliContext(), txhash)
@@ -1258,12 +1196,17 @@ func (c *CosmosChain) StartAllValSidecars(ctx context.Context) error {
 }
 
 func (c *CosmosChain) VoteOnProposalAllValidators(ctx context.Context, proposalID string, vote string) error {
+	propID, err := strconv.ParseUint(proposalID, 10, 64)
+	if err != nil {
+		return fmt.Errorf("failed to parse proposalID %s: %w", proposalID, err)
+	}
+
 	var eg errgroup.Group
 	for _, n := range c.Nodes() {
 		if n.Validator {
 			n := n
 			eg.Go(func() error {
-				return n.VoteOnProposal(ctx, valKey, proposalID, vote)
+				return n.VoteOnProposal(ctx, valKey, propID, vote)
 			})
 		}
 	}

chain/cosmos/module_TODO.go

@@ -0,0 +1,7 @@
+package cosmos
+
+// TODO: convert all to tn or c CosmosChain? (i think tn so we can chose the server to run it on)
+// TODO: convert all queries to either <Module>GetFunc or <Module>QueryFunc
+
+// TODO:
+// - move anything from chain_node to its respective module

chain/cosmos/module_auth.go

@@ -0,0 +1,130 @@
+package cosmos
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	vestingtypes "github.com/cosmos/cosmos-sdk/x/auth/vesting/types"
+
+	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+)
+
+func (c *CosmosChain) AuthGetAccount(ctx context.Context, addr string) (*cdctypes.Any, error) {
+	res, err := authtypes.NewQueryClient(c.GetNode().GrpcConn).Account(ctx, &authtypes.QueryAccountRequest{
+		Address: addr,
+	})
+	return res.Account, err
+}
+
+func (c *CosmosChain) AuthParams(ctx context.Context, addr string) (*authtypes.Params, error) {
+	res, err := authtypes.NewQueryClient(c.GetNode().GrpcConn).Params(ctx, &authtypes.QueryParamsRequest{})
+	return &res.Params, err
+}
+
+func (c *CosmosChain) AuthModuleAccounts(ctx context.Context, addr string) ([]*cdctypes.Any, error) {
+	res, err := authtypes.NewQueryClient(c.GetNode().GrpcConn).ModuleAccounts(ctx, &authtypes.QueryModuleAccountsRequest{})
+	return res.Accounts, err
+}
+
+// AuthGetModuleAccount performs a query to get the account details of the specified chain module
+func (c *CosmosChain) AuthGetModuleAccount(ctx context.Context, moduleName string) (QueryModuleAccountResponse, error) {
+	node := c.GetNode()
+	stdout, _, err := node.ExecQuery(ctx, "auth", "module-account", moduleName)
+	if err != nil {
+		return QueryModuleAccountResponse{}, err
+	}
+
+	queryRes := QueryModuleAccountResponse{}
+	err = json.Unmarshal(stdout, &queryRes)
+	if err != nil {
+		return QueryModuleAccountResponse{}, err
+	}
+	return queryRes, nil
+}
+
+// GetModuleAddress performs a query to get the address of the specified chain module
+func (c *CosmosChain) AuthGetModuleAddress(ctx context.Context, moduleName string) (string, error) {
+	queryRes, err := c.AuthGetModuleAccount(ctx, moduleName)
+	if err != nil {
+		return "", err
+	}
+	return queryRes.Account.BaseAccount.Address, nil
+}
+
+func (c *CosmosChain) AuthBech32Prefix(ctx context.Context) (string, error) {
+	res, err := authtypes.NewQueryClient(c.GetNode().GrpcConn).Bech32Prefix(ctx, &authtypes.Bech32PrefixRequest{})
+	return res.Bech32Prefix, err
+}
+
+// AddressBytesToString
+func (c *CosmosChain) AuthAddressBytesToString(ctx context.Context, addrBz []byte) (string, error) {
+	res, err := authtypes.NewQueryClient(c.GetNode().GrpcConn).AddressBytesToString(ctx, &authtypes.AddressBytesToStringRequest{
+		AddressBytes: addrBz,
+	})
+	return res.AddressString, err
+}
+
+// AddressStringToBytes
+func (c *CosmosChain) AuthAddressStringToBytes(ctx context.Context, addr string) ([]byte, error) {
+	res, err := authtypes.NewQueryClient(c.GetNode().GrpcConn).AddressStringToBytes(ctx, &authtypes.AddressStringToBytesRequest{
+		AddressString: addr,
+	})
+	return res.AddressBytes, err
+}
+
+// AccountInfo
+func (c *CosmosChain) AuthAccountInfo(ctx context.Context, addr string) (*authtypes.BaseAccount, error) {
+	res, err := authtypes.NewQueryClient(c.GetNode().GrpcConn).AccountInfo(ctx, &authtypes.QueryAccountInfoRequest{
+		Address: addr,
+	})
+	return res.Info, err
+}
+
+func (c *CosmosChain) AuthPrintAccountInfo(chain *CosmosChain, res *codectypes.Any) error {
+	switch res.TypeUrl {
+	case "/cosmos.auth.v1beta1.ModuleAccount":
+		var modAcc authtypes.ModuleAccount
+		err := chain.GetCodec().Unmarshal(res.Value, &modAcc)
+		fmt.Printf("modAcc: %+v\n", modAcc)
+		return err
+
+	case "/cosmos.vesting.v1beta1.VestingAccount":
+		var vestingAcc vestingtypes.BaseVestingAccount
+		err := chain.GetCodec().Unmarshal(res.Value, &vestingAcc)
+		fmt.Printf("BaseVestingAccount: %+v\n", vestingAcc)
+		return err
+
+	case "/cosmos.vesting.v1beta1.PeriodicVestingAccount":
+		var vestingAcc vestingtypes.PeriodicVestingAccount
+		err := chain.GetCodec().Unmarshal(res.Value, &vestingAcc)
+		fmt.Printf("PeriodicVestingAccount: %+v\n", vestingAcc)
+		return err
+
+	case "/cosmos.vesting.v1beta1.ContinuousVestingAccount":
+		var vestingAcc vestingtypes.ContinuousVestingAccount
+		err := chain.GetCodec().Unmarshal(res.Value, &vestingAcc)
+		fmt.Printf("ContinuousVestingAccount: %+v\n", vestingAcc)
+		return err
+
+	case "/cosmos.vesting.v1beta1.DelayedVestingAccount":
+		var vestingAcc vestingtypes.DelayedVestingAccount
+		err := chain.GetCodec().Unmarshal(res.Value, &vestingAcc)
+		fmt.Printf("DelayedVestingAccount: %+v\n", vestingAcc)
+		return err
+
+	case "/cosmos.vesting.v1beta1.PermanentLockedAccount":
+		var vestingAcc vestingtypes.PermanentLockedAccount
+		err := chain.GetCodec().Unmarshal(res.Value, &vestingAcc)
+		fmt.Printf("PermanentLockedAccount: %+v\n", vestingAcc)
+		return err
+
+	default:
+		var baseAcc authtypes.BaseAccount
+		err := chain.GetCodec().Unmarshal(res.Value, &baseAcc)
+		fmt.Printf("baseAcc: %+v\n", baseAcc)
+		return err
+	}
+}