Merge pull request #321 from InjectiveLabs/cp-502/fix_chain_responses_decoding

[CP-502] fix chain responses decoding

Author: aarmoa

.gitignore

@@ -1,5 +1,6 @@
 .DS_Store
 .idea/
+.vscode/
 .chain_cookie
 .exchange_cookie
 coverage.out

client/chain/chain.go

@@ -20,6 +20,7 @@ import (
 	sdkclient "github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/grpc/cmtservice"
 	"github.com/cosmos/cosmos-sdk/client/tx"
+	"github.com/cosmos/cosmos-sdk/codec"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/query"
@@ -397,13 +398,28 @@ func NewChainClient(
 	}
 
 	// init grpc connection
+	protoCodec, ok := ctx.Codec.(*codec.ProtoCodec)
+	if !ok {
+		return nil, errors.New("codec is not a proto codec")
+	}
+
 	var conn *grpc.ClientConn
 	var err error
 	stickySessionEnabled := true
 	if opts.TLSCert != nil {
-		conn, err = grpc.NewClient(network.ChainGrpcEndpoint, grpc.WithTransportCredentials(opts.TLSCert), grpc.WithContextDialer(common.DialerFunc))
+		conn, err = grpc.NewClient(
+			network.ChainGrpcEndpoint,
+			grpc.WithTransportCredentials(opts.TLSCert),
+			grpc.WithContextDialer(common.DialerFunc),
+			grpc.WithDefaultCallOptions(grpc.ForceCodec(protoCodec.GRPCCodec())),
+		)
 	} else {
-		conn, err = grpc.NewClient(network.ChainGrpcEndpoint, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(common.DialerFunc))
+		conn, err = grpc.NewClient(
+			network.ChainGrpcEndpoint,
+			grpc.WithTransportCredentials(insecure.NewCredentials()),
+			grpc.WithContextDialer(common.DialerFunc),
+			grpc.WithDefaultCallOptions(grpc.ForceCodec(protoCodec.GRPCCodec())),
+		)
 		stickySessionEnabled = false
 	}
 	if err != nil {
@@ -413,9 +429,19 @@ func NewChainClient(
 
 	var chainStreamConn *grpc.ClientConn
 	if opts.TLSCert != nil {
-		chainStreamConn, err = grpc.NewClient(network.ChainStreamGrpcEndpoint, grpc.WithTransportCredentials(opts.TLSCert), grpc.WithContextDialer(common.DialerFunc))
+		chainStreamConn, err = grpc.NewClient(
+			network.ChainStreamGrpcEndpoint,
+			grpc.WithTransportCredentials(opts.TLSCert),
+			grpc.WithContextDialer(common.DialerFunc),
+			grpc.WithDefaultCallOptions(grpc.ForceCodec(protoCodec.GRPCCodec())),
+		)
 	} else {
-		chainStreamConn, err = grpc.NewClient(network.ChainStreamGrpcEndpoint, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(common.DialerFunc))
+		chainStreamConn, err = grpc.NewClient(
+			network.ChainStreamGrpcEndpoint,
+			grpc.WithTransportCredentials(insecure.NewCredentials()),
+			grpc.WithContextDialer(common.DialerFunc),
+			grpc.WithDefaultCallOptions(grpc.ForceCodec(protoCodec.GRPCCodec())),
+		)
 	}
 	if err != nil {
 		err = errors.Wrapf(err, "failed to connect to the chain stream gRPC: %s", network.ChainStreamGrpcEndpoint)
@@ -953,7 +979,7 @@ func (c *chainClient) runBatchBroadcast() {
 }
 
 func (c *chainClient) GetGasFee() (string, error) {
-	gasPrices := strings.Trim(c.opts.GasPrices, "inj")
+	gasPrices := strings.TrimSuffix(c.txFactory.GasPrices().String(), client.InjDenom)
 
 	gas, err := strconv.ParseFloat(gasPrices, 64)
 

client/chain/chain_v2.go

@@ -20,6 +20,7 @@ import (
 	sdkclient "github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/grpc/cmtservice"
 	"github.com/cosmos/cosmos-sdk/client/tx"
+	"github.com/cosmos/cosmos-sdk/codec"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/query"
@@ -42,10 +43,8 @@ import (
 
 	erc20types "github.com/InjectiveLabs/sdk-go/chain/erc20/types"
 	evmtypes "github.com/InjectiveLabs/sdk-go/chain/evm/types"
-	exchangetypes "github.com/InjectiveLabs/sdk-go/chain/exchange/types"
 	exchangev2types "github.com/InjectiveLabs/sdk-go/chain/exchange/types/v2"
 	permissionstypes "github.com/InjectiveLabs/sdk-go/chain/permissions/types"
-	chainstreamtypes "github.com/InjectiveLabs/sdk-go/chain/stream/types"
 	chainstreamv2types "github.com/InjectiveLabs/sdk-go/chain/stream/types/v2"
 	tokenfactorytypes "github.com/InjectiveLabs/sdk-go/chain/tokenfactory/types"
 	txfeestypes "github.com/InjectiveLabs/sdk-go/chain/txfees/types"
@@ -342,12 +341,10 @@ type chainClientV2 struct {
 	authQueryClient          authtypes.QueryClient
 	authzQueryClient         authztypes.QueryClient
 	bankQueryClient          banktypes.QueryClient
-	chainStreamClient        chainstreamtypes.StreamClient
 	chainStreamV2Client      chainstreamv2types.StreamClient
 	distributionQueryClient  distributiontypes.QueryClient
 	erc20QueryClient         erc20types.QueryClient
 	evmQueryClient           evmtypes.QueryClient
-	exchangeQueryClient      exchangetypes.QueryClient
 	exchangeV2QueryClient    exchangev2types.QueryClient
 	ibcChannelQueryClient    ibcchanneltypes.QueryClient
 	ibcClientQueryClient     ibcclienttypes.QueryClient
@@ -396,13 +393,28 @@ func NewChainClientV2(
 	}
 
 	// init grpc connection
+	protoCodec, ok := ctx.Codec.(*codec.ProtoCodec)
+	if !ok {
+		return nil, errors.New("codec is not a proto codec")
+	}
+
 	var conn *grpc.ClientConn
 	var err error
 	stickySessionEnabled := true
 	if opts.TLSCert != nil {
-		conn, err = grpc.NewClient(network.ChainGrpcEndpoint, grpc.WithTransportCredentials(opts.TLSCert), grpc.WithContextDialer(common.DialerFunc))
+		conn, err = grpc.NewClient(
+			network.ChainGrpcEndpoint,
+			grpc.WithTransportCredentials(opts.TLSCert),
+			grpc.WithContextDialer(common.DialerFunc),
+			grpc.WithDefaultCallOptions(grpc.ForceCodec(protoCodec.GRPCCodec())),
+		)
 	} else {
-		conn, err = grpc.NewClient(network.ChainGrpcEndpoint, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(common.DialerFunc))
+		conn, err = grpc.NewClient(
+			network.ChainGrpcEndpoint,
+			grpc.WithTransportCredentials(insecure.NewCredentials()),
+			grpc.WithContextDialer(common.DialerFunc),
+			grpc.WithDefaultCallOptions(grpc.ForceCodec(protoCodec.GRPCCodec())),
+		)
 		stickySessionEnabled = false
 	}
 	if err != nil {
@@ -412,9 +424,20 @@ func NewChainClientV2(
 
 	var chainStreamConn *grpc.ClientConn
 	if opts.TLSCert != nil {
-		chainStreamConn, err = grpc.NewClient(network.ChainStreamGrpcEndpoint, grpc.WithTransportCredentials(opts.TLSCert), grpc.WithContextDialer(common.DialerFunc))
+		chainStreamConn, err = grpc.NewClient(
+			network.ChainStreamGrpcEndpoint,
+			grpc.WithTransportCredentials(opts.TLSCert),
+			grpc.WithContextDialer(common.DialerFunc),
+			grpc.WithDefaultCallOptions(grpc.ForceCodec(protoCodec.GRPCCodec())),
+		)
+
 	} else {
-		chainStreamConn, err = grpc.NewClient(network.ChainStreamGrpcEndpoint, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(common.DialerFunc))
+		chainStreamConn, err = grpc.NewClient(
+			network.ChainStreamGrpcEndpoint,
+			grpc.WithTransportCredentials(insecure.NewCredentials()),
+			grpc.WithContextDialer(common.DialerFunc),
+			grpc.WithDefaultCallOptions(grpc.ForceCodec(protoCodec.GRPCCodec())),
+		)
 	}
 	if err != nil {
 		err = errors.Wrapf(err, "failed to connect to the chain stream gRPC: %s", network.ChainStreamGrpcEndpoint)
@@ -448,12 +471,10 @@ func NewChainClientV2(
 		authQueryClient:          authtypes.NewQueryClient(conn),
 		authzQueryClient:         authztypes.NewQueryClient(conn),
 		bankQueryClient:          banktypes.NewQueryClient(conn),
-		chainStreamClient:        chainstreamtypes.NewStreamClient(chainStreamConn),
 		chainStreamV2Client:      chainstreamv2types.NewStreamClient(chainStreamConn),
 		distributionQueryClient:  distributiontypes.NewQueryClient(conn),
 		erc20QueryClient:         erc20types.NewQueryClient(conn),
 		evmQueryClient:           evmtypes.NewQueryClient(conn),
-		exchangeQueryClient:      exchangetypes.NewQueryClient(conn),
 		exchangeV2QueryClient:    exchangev2types.NewQueryClient(conn),
 		ibcChannelQueryClient:    ibcchanneltypes.NewQueryClient(conn),
 		ibcClientQueryClient:     ibcclienttypes.NewQueryClient(conn),
@@ -918,7 +939,7 @@ func (c *chainClientV2) runBatchBroadcast() {
 }
 
 func (c *chainClientV2) GetGasFee() (string, error) {
-	gasPrices := strings.Trim(c.opts.GasPrices, "inj")
+	gasPrices := strings.TrimSuffix(c.txFactory.GasPrices().String(), client.InjDenom)
 
 	gas, err := strconv.ParseFloat(gasPrices, 64)
 

client/chain/context.go

@@ -33,7 +33,10 @@ import (
 	"github.com/cosmos/gogoproto/proto"
 	icatypes "github.com/cosmos/ibc-go/v8/modules/apps/27-interchain-accounts/types"
 	ibcfeetypes "github.com/cosmos/ibc-go/v8/modules/apps/29-fee/types"
-	ibcapplicationtypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
+	ibctransfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
+	ibcclienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
+	ibcconnectiontypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types"
+	ibcchanneltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
 	ibccoretypes "github.com/cosmos/ibc-go/v8/modules/core/types"
 	ibclightclienttypes "github.com/cosmos/ibc-go/v8/modules/light-clients/06-solomachine"
 	ibctenderminttypes "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint"
@@ -75,54 +78,6 @@ func NewInterfaceRegistry() types.InterfaceRegistry {
 	return registry
 }
 
-// NewTxConfig initializes new Cosmos TxConfig with certain signModes enabled.
-func NewTxConfig(signModes []signingtypes.SignMode) client.TxConfig {
-	interfaceRegistry := NewInterfaceRegistry()
-	keyscodec.RegisterInterfaces(interfaceRegistry)
-	std.RegisterInterfaces(interfaceRegistry)
-	erc20types.RegisterInterfaces(interfaceRegistry)
-	evmtypes.RegisterInterfaces(interfaceRegistry)
-	exchange.RegisterInterfaces(interfaceRegistry)
-	exchangev2.RegisterInterfaces(interfaceRegistry)
-	oracle.RegisterInterfaces(interfaceRegistry)
-	insurance.RegisterInterfaces(interfaceRegistry)
-	auction.RegisterInterfaces(interfaceRegistry)
-	peggy.RegisterInterfaces(interfaceRegistry)
-	ocr.RegisterInterfaces(interfaceRegistry)
-	wasmx.RegisterInterfaces(interfaceRegistry)
-	chaintypes.RegisterInterfaces(interfaceRegistry)
-	tokenfactory.RegisterInterfaces(interfaceRegistry)
-	permissions.RegisterInterfaces(interfaceRegistry)
-	txfeestypes.RegisterInterfaces(interfaceRegistry)
-
-	// more cosmos types
-	authtypes.RegisterInterfaces(interfaceRegistry)
-	authztypes.RegisterInterfaces(interfaceRegistry)
-	vestingtypes.RegisterInterfaces(interfaceRegistry)
-	banktypes.RegisterInterfaces(interfaceRegistry)
-	crisistypes.RegisterInterfaces(interfaceRegistry)
-	distributiontypes.RegisterInterfaces(interfaceRegistry)
-	evidencetypes.RegisterInterfaces(interfaceRegistry)
-	govtypes.RegisterInterfaces(interfaceRegistry)
-	govv1types.RegisterInterfaces(interfaceRegistry)
-	paramproposaltypes.RegisterInterfaces(interfaceRegistry)
-	ibcapplicationtypes.RegisterInterfaces(interfaceRegistry)
-	ibccoretypes.RegisterInterfaces(interfaceRegistry)
-	ibclightclienttypes.RegisterInterfaces(interfaceRegistry)
-	ibctenderminttypes.RegisterInterfaces(interfaceRegistry)
-	slashingtypes.RegisterInterfaces(interfaceRegistry)
-	stakingtypes.RegisterInterfaces(interfaceRegistry)
-	upgradetypes.RegisterInterfaces(interfaceRegistry)
-	consensustypes.RegisterInterfaces(interfaceRegistry)
-	minttypes.RegisterInterfaces(interfaceRegistry)
-	feegranttypes.RegisterInterfaces(interfaceRegistry)
-	wasmtypes.RegisterInterfaces(interfaceRegistry)
-	icatypes.RegisterInterfaces(interfaceRegistry)
-
-	marshaler := codec.NewProtoCodec(interfaceRegistry)
-	return tx.NewTxConfig(marshaler, signModes)
-}
-
 // NewClientContext creates a new Cosmos Client context, where chainID
 // corresponds to Cosmos chain ID, fromSpec is either name of the key, or bech32-address
 // of the Cosmos account. Keyring is required to contain the specified key.
@@ -159,7 +114,6 @@ func NewClientContext(
 	govtypes.RegisterInterfaces(interfaceRegistry)
 	govv1types.RegisterInterfaces(interfaceRegistry)
 	paramproposaltypes.RegisterInterfaces(interfaceRegistry)
-	ibcapplicationtypes.RegisterInterfaces(interfaceRegistry)
 	ibccoretypes.RegisterInterfaces(interfaceRegistry)
 	ibclightclienttypes.RegisterInterfaces(interfaceRegistry)
 	ibctenderminttypes.RegisterInterfaces(interfaceRegistry)
@@ -172,12 +126,16 @@ func NewClientContext(
 	wasmtypes.RegisterInterfaces(interfaceRegistry)
 	icatypes.RegisterInterfaces(interfaceRegistry)
 	ibcfeetypes.RegisterInterfaces(interfaceRegistry)
+	ibcchanneltypes.RegisterInterfaces(interfaceRegistry)
+	ibcclienttypes.RegisterInterfaces(interfaceRegistry)
+	ibcconnectiontypes.RegisterInterfaces(interfaceRegistry)
+	ibctransfertypes.RegisterInterfaces(interfaceRegistry)
 
 	marshaler := codec.NewProtoCodec(interfaceRegistry)
 	encodingConfig := EncodingConfig{
 		InterfaceRegistry: interfaceRegistry,
 		Marshaler:         marshaler,
-		TxConfig: NewTxConfig([]signingtypes.SignMode{
+		TxConfig: tx.NewTxConfig(marshaler, []signingtypes.SignMode{
 			signingtypes.SignMode_SIGN_MODE_DIRECT,
 		}),
 	}

client/common/api_request_assistant.go

@@ -10,7 +10,13 @@ import (
 type APICall[Q any, R any] func(ctx context.Context, in *Q, opts ...grpc.CallOption) (*R, error)
 type APIStreamCall[Q any, S grpc.ClientStream] func(ctx context.Context, in *Q, opts ...grpc.CallOption) (S, error)
 
-func ExecuteCall[Q any, R any](ctx context.Context, cookieAssistant CookieAssistant, call APICall[Q, R], in *Q) (*R, error) {
+func ExecuteCall[Q any, R any](
+	ctx context.Context,
+	cookieAssistant CookieAssistant,
+	call APICall[Q, R],
+	in *Q,
+	opts ...grpc.CallOption,
+) (*R, error) {
 	md := cookieAssistant.RealMetadata()
 
 	if upstreamMetadata, ok := metadata.FromOutgoingContext(ctx); ok {
@@ -20,17 +26,36 @@ func ExecuteCall[Q any, R any](ctx context.Context, cookieAssistant CookieAssist
 
 	localCtx := metadata.NewOutgoingContext(ctx, md)
 
-	response, err := call(localCtx, in, grpc.Header(&md))
+	allOpts := make([]grpc.CallOption, 0, len(opts)+1)
+	allOpts = append(allOpts, opts...)
+	allOpts = append(allOpts, grpc.Header(&md))
+	response, err := call(localCtx, in, allOpts...)
 
 	cookieAssistant.ProcessResponseMetadata(md)
 
 	return response, err
 }
 
-func ExecuteStreamCall[Q any, S grpc.ClientStream](ctx context.Context, cookieAssistant CookieAssistant, call APIStreamCall[Q, S], in *Q) (S, error) {
-	localCtx := metadata.NewOutgoingContext(ctx, cookieAssistant.RealMetadata())
+func ExecuteStreamCall[Q any, S grpc.ClientStream](
+	ctx context.Context,
+	cookieAssistant CookieAssistant,
+	call APIStreamCall[Q, S],
+	in *Q,
+	opts ...grpc.CallOption,
+) (S, error) {
+	md := cookieAssistant.RealMetadata()
+
+	if upstreamMetadata, ok := metadata.FromOutgoingContext(ctx); ok {
+		// If metadata already exists in the context, merge it with the cookie metadata
+		md = metadata.Join(md, upstreamMetadata)
+	}
+
+	localCtx := metadata.NewOutgoingContext(ctx, md)
 
-	stream, callError := call(localCtx, in)
+	allOpts := make([]grpc.CallOption, 0, len(opts)+1)
+	allOpts = append(allOpts, opts...)
+	allOpts = append(allOpts, grpc.Header(&md))
+	stream, callError := call(localCtx, in, allOpts...)
 
 	if callError == nil {
 		header, err := stream.Header()

examples/chain/12_ChainStream/example.go

@@ -92,7 +92,6 @@ func main() {
 			res, err := stream.Recv()
 			if err != nil {
 				panic(err)
-				return
 			}
 			str, _ := json.MarshalIndent(res, "", "\t")
 			fmt.Print(string(str))

examples/chain/authz/query/1_Grants/example.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 
 	"github.com/InjectiveLabs/sdk-go/client"
@@ -72,10 +71,13 @@ func main() {
 
 	res, err := chainClient.GetAuthzGrants(ctx, req)
 	if err != nil {
-		fmt.Println(err)
+		panic(err)
 	}
 
-	str, _ := json.MarshalIndent(res, "", "\t")
-	fmt.Print(string(str))
+	jsonResponse, err := clientCtx.Codec.MarshalJSON(res)
+	if err != nil {
+		panic(err)
+	}
 
+	fmt.Print(string(jsonResponse))
 }

examples/chain/bank/query/2_BankBalances/example.go

@@ -61,7 +61,7 @@ func main() {
 
 	res, err := chainClient.GetBankBalances(ctx, address)
 	if err != nil {
-		fmt.Println(err)
+		panic(err)
 	}
 
 	str, _ := json.MarshalIndent(res, "", "\t")

examples/chain/exchange/28_MsgCreateGTBSpotLimitOrder/example.go

@@ -16,7 +16,7 @@ import (
 )
 
 func main() {
-	network := common.LoadNetwork("mainnet", "lb")
+	network := common.LoadNetwork("testnet", "lb")
 	tmClient, err := rpchttp.New(network.TmEndpoint)
 	if err != nil {
 		panic(err)
@@ -71,7 +71,7 @@ func main() {
 
 	defaultSubaccountID := chainClient.DefaultSubaccount(senderAddress)
 
-	marketId := "0xa508cb32923323679f29a032c70342c147c17d0145625922b0ef22e955c844c0"
+	marketId := "0x0611780ba69656949525013d947713300f56c37b6175e02f26bffa495c3208fe"
 
 	amount := decimal.NewFromFloat(2)
 	price := decimal.NewFromFloat(22.55)