feat(client/v2): factory

client/v2/autocli/keyring/interface.go

@@ -20,4 +20,7 @@ type Keyring interface {
 
 	// Sign signs the given bytes with the key with the given name.
 	Sign(name string, msg []byte, signMode signingv1beta1.SignMode) ([]byte, error)
+
+	// KeyType returns the type of the key.
+	KeyType(name string) (uint, error)
 }

client/v2/autocli/keyring/no_keyring.go

@@ -29,3 +29,7 @@ func (k NoKeyring) GetPubKey(name string) (cryptotypes.PubKey, error) {
 func (k NoKeyring) Sign(name string, msg []byte, signMode signingv1beta1.SignMode) ([]byte, error) {
 	return nil, errNoKeyring
 }
+
+func (k NoKeyring) KeyType(name string) (uint, error) {
+	return 0, errNoKeyring
+}

client/v2/internal/coins/util.go

@@ -0,0 +1,31 @@
+package coins
+
+import (
+	"errors"
+
+	base "cosmossdk.io/api/cosmos/base/v1beta1"
+	"cosmossdk.io/math"
+)
+
+var (
+	_ withAmount = &base.Coin{}
+	_ withAmount = &base.DecCoin{}
+)
+
+type withAmount interface {
+	GetAmount() string
+}
+
+// IsZero check if given coins are zero.
+func IsZero[T withAmount](coins []T) (bool, error) {
+	for _, coin := range coins {
+		amount, ok := math.NewIntFromString(coin.GetAmount())
+		if !ok {
+			return false, errors.New("invalid coin amount")
+		}
+		if !amount.IsZero() {
+			return false, nil
+		}
+	}
+	return true, nil
+}

client/v2/internal/coins/util_test.go

@@ -0,0 +1,83 @@
+package coins
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	base "cosmossdk.io/api/cosmos/base/v1beta1"
+)
+
+func TestCoinIsZero(t *testing.T) {
+	type testCase[T withAmount] struct {
+		name   string
+		coins  []T
+		isZero bool
+	}
+	tests := []testCase[*base.Coin]{
+		{
+			name: "not zero coin",
+			coins: []*base.Coin{
+				{
+					Denom:  "stake",
+					Amount: "100",
+				},
+			},
+			isZero: false,
+		},
+		{
+			name: "zero coin",
+			coins: []*base.Coin{
+				{
+					Denom:  "stake",
+					Amount: "0",
+				},
+			},
+			isZero: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := IsZero(tt.coins)
+			require.NoError(t, err)
+			require.Equal(t, got, tt.isZero)
+		})
+	}
+}
+
+func TestDecCoinIsZero(t *testing.T) {
+	type testCase[T withAmount] struct {
+		name   string
+		coins  []T
+		isZero bool
+	}
+	tests := []testCase[*base.DecCoin]{
+		{
+			name: "not zero coin",
+			coins: []*base.DecCoin{
+				{
+					Denom:  "stake",
+					Amount: "100",
+				},
+			},
+			isZero: false,
+		},
+		{
+			name: "zero coin",
+			coins: []*base.DecCoin{
+				{
+					Denom:  "stake",
+					Amount: "0",
+				},
+			},
+			isZero: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := IsZero(tt.coins)
+			require.NoError(t, err)
+			require.Equal(t, got, tt.isZero)
+		})
+	}
+}

client/v2/internal/grpc/client.go

@@ -0,0 +1,22 @@
+package grpc
+
+import (
+	"context"
+	"fmt"
+
+	gogogrpc "github.com/cosmos/gogoproto/grpc"
+	"google.golang.org/grpc"
+)
+
+var _ gogogrpc.ClientConn = ClientConn{}
+
+type ClientConn struct{}
+
+func (c ClientConn) Invoke(ctx context.Context, method string, args, reply interface{}, opts ...grpc.CallOption) error {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (c ClientConn) NewStream(ctx context.Context, desc *grpc.StreamDesc, method string, opts ...grpc.CallOption) (grpc.ClientStream, error) {
+	return nil, fmt.Errorf("streaming rpc not supported")
+}

client/v2/offchain/sign.go

@@ -63,7 +63,7 @@ func Sign(ctx client.Context, rawBytes []byte, fromName, indent, encoding, outpu
 
 // sign signs a digest with provided key and SignMode.
 func sign(ctx client.Context, fromName, digest string) (*apitx.Tx, error) {
-	keybase, err := keyring.NewAutoCLIKeyring(ctx.Keyring)
+	keybase, err := keyring.NewAutoCLIKeyring(ctx.Keyring, ctx.AddressCodec)
 	if err != nil {
 		return nil, err
 	}

client/v2/tx/account.go

@@ -0,0 +1,110 @@
+package tx
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	gogogrpc "github.com/cosmos/gogoproto/grpc"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+
+	"cosmossdk.io/core/address"
+	authtypes "cosmossdk.io/x/auth/types"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	grpctypes "github.com/cosmos/cosmos-sdk/types/grpc"
+)
+
+// TODO: move to internal
+
+var _ AccountRetriever = accountRetriever{}
+
+// Account defines a read-only version of the auth module's AccountI.
+type Account interface {
+	GetAddress() sdk.AccAddress
+	GetPubKey() cryptotypes.PubKey // can return nil.
+	GetAccountNumber() uint64
+	GetSequence() uint64
+}
+
+// AccountRetriever defines the interfaces required by transactions to
+// ensure an account exists and to be able to query for account fields necessary
+// for signing.
+type AccountRetriever interface {
+	GetAccount(context.Context, sdk.AccAddress) (Account, error)
+	GetAccountWithHeight(context.Context, sdk.AccAddress) (Account, int64, error)
+	EnsureExists(context.Context, sdk.AccAddress) error
+	GetAccountNumberSequence(context.Context, sdk.AccAddress) (accNum, accSeq uint64, err error)
+}
+
+type accountRetriever struct {
+	ac       address.Codec
+	conn     gogogrpc.ClientConn
+	registry codectypes.InterfaceRegistry
+}
+
+func newAccountRetriever(ac address.Codec, conn gogogrpc.ClientConn, registry codectypes.InterfaceRegistry) *accountRetriever {
+	return &accountRetriever{
+		ac:       ac,
+		conn:     conn,
+		registry: registry,
+	}
+}
+
+func (a accountRetriever) GetAccount(ctx context.Context, addr sdk.AccAddress) (Account, error) {
+	acc, _, err := a.GetAccountWithHeight(ctx, addr)
+	return acc, err
+}
+
+func (a accountRetriever) GetAccountWithHeight(ctx context.Context, addr sdk.AccAddress) (Account, int64, error) {
+	var header metadata.MD
+
+	qc := authtypes.NewQueryClient(a.conn)
+
+	res, err := qc.Account(ctx, &authtypes.QueryAccountRequest{Address: addr.String()}, grpc.Header(&header))
+	if err != nil {
+		return nil, 0, err
+	}
+
+	blockHeight := header.Get(grpctypes.GRPCBlockHeightHeader)
+	if l := len(blockHeight); l != 1 {
+		return nil, 0, fmt.Errorf("unexpected '%s' header length; got %d, expected: %d", grpctypes.GRPCBlockHeightHeader, l, 1)
+	}
+
+	nBlockHeight, err := strconv.Atoi(blockHeight[0])
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to parse block height: %w", err)
+	}
+
+	var acc Account
+	if err := a.registry.UnpackAny(res.Account, &acc); err != nil {
+		return nil, 0, err
+	}
+
+	return acc, int64(nBlockHeight), nil
+
+}
+
+func (a accountRetriever) EnsureExists(ctx context.Context, addr sdk.AccAddress) error {
+	if _, err := a.GetAccount(ctx, addr); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (a accountRetriever) GetAccountNumberSequence(ctx context.Context, addr sdk.AccAddress) (accNum, accSeq uint64, err error) {
+	acc, err := a.GetAccount(ctx, addr)
+	if err != nil {
+		if status.Code(err) == codes.NotFound {
+			return 0, 0, nil
+		}
+		return 0, 0, err
+	}
+
+	return acc.GetAccountNumber(), acc.GetSequence(), nil
+}