github.com/cosmos/cosmos-sdk@v0.50.10/client/keys/show_test.go (about)

     1  package keys
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/require"
     9  
    10  	"github.com/cosmos/cosmos-sdk/client"
    11  	"github.com/cosmos/cosmos-sdk/client/flags"
    12  	"github.com/cosmos/cosmos-sdk/crypto/hd"
    13  	"github.com/cosmos/cosmos-sdk/crypto/keyring"
    14  	"github.com/cosmos/cosmos-sdk/crypto/keys/multisig"
    15  	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
    16  	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
    17  	"github.com/cosmos/cosmos-sdk/testutil"
    18  	"github.com/cosmos/cosmos-sdk/testutil/testdata"
    19  	sdk "github.com/cosmos/cosmos-sdk/types"
    20  	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
    21  )
    22  
    23  func Test_multiSigKey_Properties(t *testing.T) {
    24  	tmpKey1 := secp256k1.GenPrivKeyFromSecret([]byte("mySecret"))
    25  	pk := multisig.NewLegacyAminoPubKey(
    26  		1,
    27  		[]cryptotypes.PubKey{tmpKey1.PubKey()},
    28  	)
    29  	k, err := keyring.NewMultiRecord("myMultisig", pk)
    30  	require.NoError(t, err)
    31  	require.Equal(t, "myMultisig", k.Name)
    32  	require.Equal(t, keyring.TypeMulti, k.GetType())
    33  
    34  	pub, err := k.GetPubKey()
    35  	require.NoError(t, err)
    36  	require.Equal(t, "D3923267FA8A3DD367BB768FA8BDC8FF7F89DA3F", pub.Address().String())
    37  
    38  	addr, err := k.GetAddress()
    39  	require.NoError(t, err)
    40  	require.Equal(t, "cosmos16wfryel63g7axeamw68630wglalcnk3l0zuadc", sdk.MustBech32ifyAddressBytes("cosmos", addr))
    41  }
    42  
    43  func Test_showKeysCmd(t *testing.T) {
    44  	cmd := ShowKeysCmd()
    45  	require.NotNil(t, cmd)
    46  	require.Equal(t, "false", cmd.Flag(FlagAddress).DefValue)
    47  	require.Equal(t, "false", cmd.Flag(FlagPublicKey).DefValue)
    48  }
    49  
    50  func Test_runShowCmd(t *testing.T) {
    51  	cmd := ShowKeysCmd()
    52  	cmd.Flags().AddFlagSet(Commands().PersistentFlags())
    53  	mockIn := testutil.ApplyMockIODiscardOutErr(cmd)
    54  
    55  	kbHome := t.TempDir()
    56  	cdc := moduletestutil.MakeTestEncodingConfig().Codec
    57  	kb, err := keyring.New(sdk.KeyringServiceName(), keyring.BackendTest, kbHome, mockIn, cdc)
    58  	require.NoError(t, err)
    59  
    60  	clientCtx := client.Context{}.
    61  		WithKeyringDir(kbHome).
    62  		WithCodec(cdc)
    63  	ctx := context.WithValue(context.Background(), client.ClientContextKey, &clientCtx)
    64  
    65  	cmd.SetArgs([]string{"invalid"})
    66  	require.EqualError(t, cmd.ExecuteContext(ctx), "invalid is not a valid name or address: decoding bech32 failed: invalid bech32 string length 7")
    67  
    68  	cmd.SetArgs([]string{"invalid1", "invalid2"})
    69  	require.EqualError(t, cmd.ExecuteContext(ctx), "invalid1 is not a valid name or address: decoding bech32 failed: invalid separator index 7")
    70  
    71  	fakeKeyName1 := "runShowCmd_Key1"
    72  	fakeKeyName2 := "runShowCmd_Key2"
    73  
    74  	t.Cleanup(func() {
    75  		cleanupKeys(t, kb, "runShowCmd_Key1")
    76  		cleanupKeys(t, kb, "runShowCmd_Key2")
    77  	})
    78  
    79  	path := hd.NewFundraiserParams(1, sdk.CoinType, 0).String()
    80  	_, err = kb.NewAccount(fakeKeyName1, testdata.TestMnemonic, "", path, hd.Secp256k1)
    81  	require.NoError(t, err)
    82  
    83  	path2 := hd.NewFundraiserParams(1, sdk.CoinType, 1).String()
    84  	_, err = kb.NewAccount(fakeKeyName2, testdata.TestMnemonic, "", path2, hd.Secp256k1)
    85  	require.NoError(t, err)
    86  
    87  	// Now try single key
    88  	cmd.SetArgs([]string{
    89  		fakeKeyName1,
    90  		fmt.Sprintf("--%s=%s", flags.FlagKeyringDir, kbHome),
    91  		fmt.Sprintf("--%s=", FlagBechPrefix),
    92  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
    93  	})
    94  	require.EqualError(t, cmd.ExecuteContext(ctx), "invalid Bech32 prefix encoding provided: ")
    95  
    96  	cmd.SetArgs([]string{
    97  		fakeKeyName1,
    98  		fmt.Sprintf("--%s=%s", flags.FlagKeyringDir, kbHome),
    99  		fmt.Sprintf("--%s=%s", FlagBechPrefix, sdk.PrefixAccount),
   100  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   101  	})
   102  
   103  	// try fetch by name
   104  	require.NoError(t, cmd.ExecuteContext(ctx))
   105  
   106  	// try fetch by addr
   107  	k, err := kb.Key(fakeKeyName1)
   108  	require.NoError(t, err)
   109  	addr, err := k.GetAddress()
   110  	require.NoError(t, err)
   111  	cmd.SetArgs([]string{
   112  		addr.String(),
   113  		fmt.Sprintf("--%s=%s", flags.FlagKeyringDir, kbHome),
   114  		fmt.Sprintf("--%s=%s", FlagBechPrefix, sdk.PrefixAccount),
   115  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   116  	})
   117  
   118  	require.NoError(t, cmd.ExecuteContext(ctx))
   119  
   120  	// Now try multisig key - set bech to acc
   121  	cmd.SetArgs([]string{
   122  		fakeKeyName1, fakeKeyName2,
   123  		fmt.Sprintf("--%s=%s", flags.FlagKeyringDir, kbHome),
   124  		fmt.Sprintf("--%s=%s", FlagBechPrefix, sdk.PrefixAccount),
   125  		fmt.Sprintf("--%s=0", flagMultiSigThreshold),
   126  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   127  	})
   128  	require.EqualError(t, cmd.ExecuteContext(ctx), "threshold must be a positive integer")
   129  
   130  	cmd.SetArgs([]string{
   131  		fakeKeyName1, fakeKeyName2,
   132  		fmt.Sprintf("--%s=%s", flags.FlagKeyringDir, kbHome),
   133  		fmt.Sprintf("--%s=%s", FlagBechPrefix, sdk.PrefixAccount),
   134  		fmt.Sprintf("--%s=2", flagMultiSigThreshold),
   135  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   136  	})
   137  	require.NoError(t, cmd.ExecuteContext(ctx))
   138  
   139  	// Now try multisig key - set bech to acc + threshold=2
   140  	cmd.SetArgs([]string{
   141  		fakeKeyName1, fakeKeyName2,
   142  		fmt.Sprintf("--%s=%s", flags.FlagKeyringDir, kbHome),
   143  		fmt.Sprintf("--%s=acc", FlagBechPrefix),
   144  		fmt.Sprintf("--%s=true", FlagDevice),
   145  		fmt.Sprintf("--%s=2", flagMultiSigThreshold),
   146  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   147  	})
   148  	require.EqualError(t, cmd.ExecuteContext(ctx), "the device flag (-d) can only be used for accounts stored in devices")
   149  
   150  	cmd.SetArgs([]string{
   151  		fakeKeyName1, fakeKeyName2,
   152  		fmt.Sprintf("--%s=%s", flags.FlagKeyringDir, kbHome),
   153  		fmt.Sprintf("--%s=val", FlagBechPrefix),
   154  		fmt.Sprintf("--%s=true", FlagDevice),
   155  		fmt.Sprintf("--%s=2", flagMultiSigThreshold),
   156  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   157  	})
   158  	require.EqualError(t, cmd.ExecuteContext(ctx), "the device flag (-d) can only be used for accounts")
   159  
   160  	cmd.SetArgs([]string{
   161  		fakeKeyName1, fakeKeyName2,
   162  		fmt.Sprintf("--%s=%s", flags.FlagKeyringDir, kbHome),
   163  		fmt.Sprintf("--%s=val", FlagBechPrefix),
   164  		fmt.Sprintf("--%s=true", FlagDevice),
   165  		fmt.Sprintf("--%s=2", flagMultiSigThreshold),
   166  		fmt.Sprintf("--%s=true", FlagPublicKey),
   167  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   168  	})
   169  	require.EqualError(t, cmd.ExecuteContext(ctx), "the device flag (-d) can only be used for addresses not pubkeys")
   170  }
   171  
   172  func Test_validateMultisigThreshold(t *testing.T) {
   173  	type args struct {
   174  		k     int
   175  		nKeys int
   176  	}
   177  	tests := []struct {
   178  		name    string
   179  		args    args
   180  		wantErr bool
   181  	}{
   182  		{"zeros", args{0, 0}, true},
   183  		{"1-0", args{1, 0}, true},
   184  		{"1-1", args{1, 1}, false},
   185  		{"1-2", args{1, 1}, false},
   186  		{"1-2", args{2, 1}, true},
   187  	}
   188  	for _, tt := range tests {
   189  		tt := tt
   190  		t.Run(tt.name, func(t *testing.T) {
   191  			if err := validateMultisigThreshold(tt.args.k, tt.args.nKeys); (err != nil) != tt.wantErr {
   192  				t.Errorf("validateMultisigThreshold() error = %v, wantErr %v", err, tt.wantErr)
   193  			}
   194  		})
   195  	}
   196  }
   197  
   198  func Test_getBechKeyOut(t *testing.T) {
   199  	type args struct {
   200  		bechPrefix string
   201  	}
   202  	tests := []struct {
   203  		name    string
   204  		args    args
   205  		want    bechKeyOutFn
   206  		wantErr bool
   207  	}{
   208  		{"empty", args{""}, nil, true},
   209  		{"wrong", args{"???"}, nil, true},
   210  		{"acc", args{sdk.PrefixAccount}, MkAccKeyOutput, false},
   211  		{"val", args{sdk.PrefixValidator}, MkValKeyOutput, false},
   212  		{"cons", args{sdk.PrefixConsensus}, MkConsKeyOutput, false},
   213  	}
   214  	for _, tt := range tests {
   215  		tt := tt
   216  		t.Run(tt.name, func(t *testing.T) {
   217  			got, err := getBechKeyOut(tt.args.bechPrefix)
   218  			if tt.wantErr {
   219  				require.Error(t, err)
   220  			} else {
   221  				require.NoError(t, err)
   222  				require.NotNil(t, got)
   223  			}
   224  		})
   225  	}
   226  }