refactor(x/auth): removal of Address.String()

x/auth/ante/fee.go

@@ -112,11 +112,16 @@ func (dfd DeductFeeDecorator) checkDeductFee(ctx sdk.Context, sdkTx sdk.Tx, fee
 		}
 	}
 
+	deductFeesFromAddr, err := dfd.accountKeeper.AddressCodec().BytesToString(deductFeesFrom)
+	if err != nil {
+		return err
+	}
+
 	events := sdk.Events{
 		sdk.NewEvent(
 			sdk.EventTypeTx,
 			sdk.NewAttribute(sdk.AttributeKeyFee, fee.String()),
-			sdk.NewAttribute(sdk.AttributeKeyFeePayer, sdk.AccAddress(deductFeesFrom).String()),
+			sdk.NewAttribute(sdk.AttributeKeyFeePayer, deductFeesFromAddr),
 		),
 	}
 	ctx.EventManager().EmitEvents(events)

x/auth/ante/sigverify.go

@@ -340,8 +340,13 @@ func (svd SigVerificationDecorator) verifySig(ctx sdk.Context, tx sdk.Tx, acc sd
 
 	anyPk, _ := codectypes.NewAnyWithValue(pubKey)
 
+	addr, err := svd.ak.AddressCodec().BytesToString(acc.GetAddress())
+	if err != nil {
+		return err
+	}
+
 	signerData := txsigning.SignerData{
-		Address:       acc.GetAddress().String(),
+		Address:       addr,
 		ChainID:       chainID,
 		AccountNumber: accNum,
 		Sequence:      acc.GetSequence(),
@@ -355,7 +360,7 @@ func (svd SigVerificationDecorator) verifySig(ctx sdk.Context, tx sdk.Tx, acc sd
 		return fmt.Errorf("expected tx to implement V2AdaptableTx, got %T", tx)
 	}
 	txData := adaptableTx.GetSigningTxData()
-	err := authsigning.VerifySignature(ctx, pubKey, signerData, sig.Data, svd.signModeHandler, txData)
+	err = authsigning.VerifySignature(ctx, pubKey, signerData, sig.Data, svd.signModeHandler, txData)
 	if err != nil {
 		var errMsg string
 		if OnlyLegacyAminoSigners(sig.Data) {
@@ -386,7 +391,11 @@ func (svd SigVerificationDecorator) setPubKey(ctx sdk.Context, acc sdk.AccountI,
 		// if we're not in simulation mode, and we do not have a valid pubkey
 		// for this signer, then we simply error.
 		if svd.ak.Environment().TransactionService.ExecMode(ctx) != transaction.ExecModeSimulate {
-			return fmt.Errorf("the account %s is without a pubkey and did not provide a pubkey in the tx to set it", acc.GetAddress().String())
+			addr, err := svd.ak.AddressCodec().BytesToString(acc.GetAddress())
+			if err != nil {
+				return fmt.Errorf("could not convert address to string: %s", err.Error())
+			}
+			return fmt.Errorf("the account %s is without a pubkey and did not provide a pubkey in the tx to set it", addr)
 		}
 		// if we're in simulation mode, then we can populate the pubkey with the
 		// sim one and simply return.
@@ -398,7 +407,11 @@ func (svd SigVerificationDecorator) setPubKey(ctx sdk.Context, acc sdk.AccountI,
 	// if the address does not match the pubkey, then we error.
 	// TODO: in the future the relationship between address and pubkey should be more flexible.
 	if !acc.GetAddress().Equals(sdk.AccAddress(txPubKey.Address().Bytes())) {
-		return sdkerrors.ErrInvalidPubKey.Wrapf("the account %s cannot be claimed by public key with address %x", acc.GetAddress(), txPubKey.Address())
+		addr, err := svd.ak.AddressCodec().BytesToString(acc.GetAddress())
+		if err != nil {
+			return fmt.Errorf("could not convert address to string: %s", err.Error())
+		}
+		return sdkerrors.ErrInvalidPubKey.Wrapf("the account %s cannot be claimed by public key with address %x", addr, txPubKey.Address())
 	}
 
 	err := verifyIsOnCurve(txPubKey)

x/auth/ante/sigverify_internal_test.go

@@ -6,12 +6,14 @@ import (
 
 	"github.com/stretchr/testify/require"
 
+	coreaddress "cosmossdk.io/core/address"
 	"cosmossdk.io/core/appmodule"
 	"cosmossdk.io/core/transaction"
 	"cosmossdk.io/x/auth/ante"
 	authcodec "cosmossdk.io/x/auth/codec"
 	authtypes "cosmossdk.io/x/auth/types"
 
+	"github.com/cosmos/cosmos-sdk/codec/address"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -26,6 +28,10 @@ func (*mockAccount) Environment() appmodule.Environment {
 	}
 }
 
+func (*mockAccount) AddressCodec() coreaddress.Codec {
+	return address.NewBech32Codec("cosmos")
+}
+
 type mockTransactionService struct {
 	transaction.Service
 }

x/auth/ante/testutil_test.go

@@ -79,12 +79,15 @@ func SetupTestSuite(t *testing.T, isCheckTx bool) *AnteTestSuite {
 		"random":                 {"random"},
 	}
 
+	ac := authcodec.NewBech32Codec("cosmos")
+	authorityAddr, err := ac.BytesToString(types.NewModuleAddress("gov"))
+	require.NoError(t, err)
 	suite.accountKeeper = keeper.NewAccountKeeper(
-		runtime.NewEnvironment(runtime.NewKVStoreService(key), log.NewNopLogger()), suite.encCfg.Codec, types.ProtoBaseAccount, maccPerms, authcodec.NewBech32Codec("cosmos"),
-		sdk.Bech32MainPrefix, types.NewModuleAddress("gov").String(), nil,
+		runtime.NewEnvironment(runtime.NewKVStoreService(key), log.NewNopLogger()), suite.encCfg.Codec,
+		types.ProtoBaseAccount, maccPerms, ac, sdk.Bech32MainPrefix, authorityAddr, nil,
 	)
 	suite.accountKeeper.GetModuleAccount(suite.ctx, types.FeeCollectorName)
-	err := suite.accountKeeper.Params.Set(suite.ctx, types.DefaultParams())
+	err = suite.accountKeeper.Params.Set(suite.ctx, types.DefaultParams())
 	require.NoError(t, err)
 
 	// We're using TestMsg encoding in some tests, so register it here.
@@ -241,8 +244,12 @@ func (suite *AnteTestSuite) CreateTestTx(
 	// Second round: all signer infos are set, so each signer can sign.
 	sigsV2 = []signing.SignatureV2{}
 	for i, priv := range privs {
+		addr, err := suite.accountKeeper.AddressCodec().BytesToString(priv.PubKey().Address())
+		if err != nil {
+			return nil, err
+		}
 		signerData := xauthsigning.SignerData{
-			Address:       sdk.AccAddress(priv.PubKey().Address()).String(),
+			Address:       addr,
 			ChainID:       chainID,
 			AccountNumber: accNums[i],
 			Sequence:      accSeqs[i],

x/auth/client/cli/tx_multisign.go

@@ -136,11 +136,15 @@ func makeMultiSignCmd() func(cmd *cobra.Command, args []string) (err error) {
 				if err != nil {
 					return err
 				}
+				sigAddr, err := clientCtx.AddressCodec.BytesToString(sig.PubKey.Address())
+				if err != nil {
+					return err
+				}
 				txSignerData := txsigning.SignerData{
 					ChainID:       txFactory.ChainID(),
 					AccountNumber: txFactory.AccountNumber(),
 					Sequence:      txFactory.Sequence(),
-					Address:       sdk.AccAddress(sig.PubKey.Address()).String(),
+					Address:       sigAddr,
 					PubKey: &anypb.Any{
 						TypeUrl: anyPk.TypeUrl,
 						Value:   anyPk.Value,
@@ -310,6 +314,11 @@ func makeBatchMultisignCmd() func(cmd *cobra.Command, args []string) error {
 			multisigPub := pubKey.(*kmultisig.LegacyAminoPubKey)
 			multisigSig := multisig.NewMultisig(len(multisigPub.PubKeys))
 
+			address, err := clientCtx.AddressCodec.BytesToString(pubKey.Address())
+			if err != nil {
+				return err
+			}
+
 			anyPk, err := codectypes.NewAnyWithValue(multisigPub)
 			if err != nil {
 				return err
@@ -318,7 +327,7 @@ func makeBatchMultisignCmd() func(cmd *cobra.Command, args []string) error {
 				ChainID:       txFactory.ChainID(),
 				AccountNumber: txFactory.AccountNumber(),
 				Sequence:      txFactory.Sequence(),
-				Address:       sdk.AccAddress(pubKey.Address()).String(),
+				Address:       address,
 				PubKey: &anypb.Any{
 					TypeUrl: anyPk.TypeUrl,
 					Value:   anyPk.Value,

x/auth/client/cli/validate_sigs.go

@@ -109,6 +109,12 @@ func printAndValidateSigs(
 			success = false
 		}
 
+		sigStrAddr, err := clientCtx.AddressCodec.BytesToString(sigAddr)
+		if err != nil {
+			cmd.PrintErrf("failed to convert address to string: %s\n", sigAddr)
+			return false
+		}
+
 		// validate the actual signature over the transaction bytes since we can
 		// reach out to a full node to query accounts.
 		if !offline && success {
@@ -119,7 +125,7 @@ func printAndValidateSigs(
 			}
 
 			signingData := authsigning.SignerData{
-				Address:       sigAddr.String(),
+				Address:       sigStrAddr,
 				ChainID:       chainID,
 				AccountNumber: accNum,
 				Sequence:      accSeq,
@@ -155,7 +161,7 @@ func printAndValidateSigs(
 			}
 		}
 
-		cmd.Printf("  %d: %s\t\t\t[%s]%s%s\n", i, sigAddr.String(), sigSanity, multiSigHeader, multiSigMsg)
+		cmd.Printf("  %d: %s\t\t\t[%s]%s%s\n", i, sigStrAddr, sigSanity, multiSigHeader, multiSigMsg)
 	}
 
 	cmd.Println("")

x/auth/client/testutil/helpers.go

@@ -65,7 +65,7 @@ func TxMultiSignExec(clientCtx client.Context, from, filename string, extraArgs
 
 func TxSignBatchExec(clientCtx client.Context, from fmt.Stringer, filename string, extraArgs ...string) (testutil.BufferWriter, error) {
 	args := []string{
-		fmt.Sprintf("--from=%s", from.String()),
+		fmt.Sprintf("--from=%s", from),
 		filename,
 	}
 

x/auth/keeper/deterministic_test.go

@@ -71,14 +71,18 @@ func (suite *DeterministicTestSuite) SetupTest() {
 		randomPerm:               {"random"},
 	}
 
+	ac := authcodec.NewBech32Codec("cosmos")
+	authorityAddr, err := ac.BytesToString(types.NewModuleAddress("gov"))
+	suite.Require().NoError(err)
+
 	suite.accountKeeper = keeper.NewAccountKeeper(
 		env,
 		suite.encCfg.Codec,
 		types.ProtoBaseAccount,
 		maccPerms,
-		authcodec.NewBech32Codec("cosmos"),
+		ac,
 		"cosmos",
-		types.NewModuleAddress("gov").String(),
+		authorityAddr,
 		nil,
 	)
 
@@ -123,7 +127,9 @@ func (suite *DeterministicTestSuite) createAndSetAccounts(t *rapid.T, count int)
 func (suite *DeterministicTestSuite) TestGRPCQueryAccount() {
 	rapid.Check(suite.T(), func(t *rapid.T) {
 		accs := suite.createAndSetAccounts(t, 1)
-		req := &types.QueryAccountRequest{Address: accs[0].GetAddress().String()}
+		accAddr, err := suite.accountKeeper.AddressCodec().BytesToString(accs[0].GetAddress())
+		suite.Require().NoError(err)
+		req := &types.QueryAccountRequest{Address: accAddr}
 		testdata.DeterministicIterations(suite.T(), suite.ctx, req, suite.queryClient.Account, 0, true)
 	})
 
@@ -134,7 +140,10 @@ func (suite *DeterministicTestSuite) TestGRPCQueryAccount() {
 	acc1 := types.NewBaseAccount(addr, &secp256k1.PubKey{Key: pub}, accNum, seq)
 	suite.accountKeeper.SetAccount(suite.ctx, acc1)
 
-	req := &types.QueryAccountRequest{Address: acc1.GetAddress().String()}
+	accAddr, err := suite.accountKeeper.AddressCodec().BytesToString(acc1.GetAddress())
+	suite.Require().NoError(err)
+
+	req := &types.QueryAccountRequest{Address: accAddr}
 
 	testdata.DeterministicIterations(suite.T(), suite.ctx, req, suite.queryClient.Account, 1543, false)
 }
@@ -230,7 +239,10 @@ func (suite *DeterministicTestSuite) TestGRPCQueryAccountInfo() {
 		accs := suite.createAndSetAccounts(t, 1)
 		suite.Require().Len(accs, 1)
 
-		req := &types.QueryAccountInfoRequest{Address: accs[0].GetAddress().String()}
+		acc0Addr, err := suite.accountKeeper.AddressCodec().BytesToString(accs[0].GetAddress())
+		suite.Require().NoError(err)
+
+		req := &types.QueryAccountInfoRequest{Address: acc0Addr}
 		testdata.DeterministicIterations(suite.T(), suite.ctx, req, suite.queryClient.AccountInfo, 0, true)
 	})
 
@@ -239,9 +251,11 @@ func (suite *DeterministicTestSuite) TestGRPCQueryAccountInfo() {
 	seq := uint64(10)
 
 	acc := types.NewBaseAccount(addr, &secp256k1.PubKey{Key: pub}, accNum, seq)
+	accAddr, err := suite.accountKeeper.AddressCodec().BytesToString(acc.GetAddress())
+	suite.Require().NoError(err)
 
 	suite.accountKeeper.SetAccount(suite.ctx, acc)
-	req := &types.QueryAccountInfoRequest{Address: acc.GetAddress().String()}
+	req := &types.QueryAccountInfoRequest{Address: accAddr}
 	testdata.DeterministicIterations(suite.T(), suite.ctx, req, suite.queryClient.AccountInfo, 1543, false)
 }
 
@@ -292,14 +306,17 @@ func (suite *DeterministicTestSuite) TestGRPCQueryModuleAccounts() {
 			maccPerms[maccs[i]] = mPerms
 		}
 
+		authorityAddr, err := ac.BytesToString(types.NewModuleAddress("gov"))
+		suite.Require().NoError(err)
+
 		ak := keeper.NewAccountKeeper(
 			suite.environment,
 			suite.encCfg.Codec,
 			types.ProtoBaseAccount,
 			maccPerms,
-			authcodec.NewBech32Codec("cosmos"),
+			ac,
 			"cosmos",
-			types.NewModuleAddress("gov").String(),
+			authorityAddr,
 			nil,
 		)
 		suite.setModuleAccounts(suite.ctx, ak, maccs)
@@ -340,14 +357,18 @@ func (suite *DeterministicTestSuite) TestGRPCQueryModuleAccountByName() {
 
 		maccPerms[mName] = mPerms
 
+		ac := authcodec.NewBech32Codec("cosmos")
+		authorityAddr, err := ac.BytesToString(types.NewModuleAddress("gov"))
+		suite.Require().NoError(err)
+
 		ak := keeper.NewAccountKeeper(
 			suite.environment,
 			suite.encCfg.Codec,
 			types.ProtoBaseAccount,
 			maccPerms,
-			authcodec.NewBech32Codec("cosmos"),
+			ac,
 			"cosmos",
-			types.NewModuleAddress("gov").String(),
+			authorityAddr,
 			nil,
 		)
 		suite.setModuleAccounts(suite.ctx, ak, []string{mName})

x/auth/keeper/grpc_query_test.go

@@ -76,6 +76,8 @@ func (suite *KeeperTestSuite) TestGRPCQueryAccounts() {
 func (suite *KeeperTestSuite) TestGRPCQueryAccount() {
 	var req *types.QueryAccountRequest
 	_, _, addr := testdata.KeyTestPubAddr()
+	addrString, err := suite.accountKeeper.AddressCodec().BytesToString(addr)
+	suite.Require().NoError(err)
 
 	testCases := []struct {
 		msg       string
@@ -110,7 +112,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryAccount() {
 		{
 			"account not found",
 			func() {
-				req = &types.QueryAccountRequest{Address: addr.String()}
+				req = &types.QueryAccountRequest{Address: addrString}
 			},
 			false,
 			func(res *types.QueryAccountResponse) {},
@@ -120,7 +122,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryAccount() {
 			func() {
 				suite.accountKeeper.SetAccount(suite.ctx,
 					suite.accountKeeper.NewAccountWithAddress(suite.ctx, addr))
-				req = &types.QueryAccountRequest{Address: addr.String()}
+				req = &types.QueryAccountRequest{Address: addrString}
 			},
 			true,
 			func(res *types.QueryAccountResponse) {
@@ -508,13 +510,16 @@ func (suite *KeeperTestSuite) TestQueryAccountInfo() {
 	suite.Require().NoError(acc.SetSequence(10))
 	suite.accountKeeper.SetAccount(suite.ctx, acc)
 
+	addrString, err := suite.accountKeeper.AddressCodec().BytesToString(addr)
+	suite.Require().NoError(err)
+
 	res, err := suite.queryClient.AccountInfo(context.Background(), &types.QueryAccountInfoRequest{
-		Address: addr.String(),
+		Address: addrString,
 	})
 
 	suite.Require().NoError(err)
 	suite.Require().NotNil(res.Info)
-	suite.Require().Equal(addr.String(), res.Info.Address)
+	suite.Require().Equal(addrString, res.Info.Address)
 	suite.Require().Equal(acc.GetAccountNumber(), res.Info.AccountNumber)
 	suite.Require().Equal(acc.GetSequence(), res.Info.Sequence)
 	suite.Require().Equal("/"+proto.MessageName(pk), res.Info.PubKey.TypeUrl)
@@ -526,13 +531,15 @@ func (suite *KeeperTestSuite) TestQueryAccountInfo() {
 func (suite *KeeperTestSuite) TestQueryAccountInfoWithoutPubKey() {
 	acc := suite.accountKeeper.NewAccountWithAddress(suite.ctx, addr)
 	suite.accountKeeper.SetAccount(suite.ctx, acc)
+	addrString, err := suite.accountKeeper.AddressCodec().BytesToString(addr)
+	suite.Require().NoError(err)
 
 	res, err := suite.queryClient.AccountInfo(context.Background(), &types.QueryAccountInfoRequest{
-		Address: addr.String(),
+		Address: addrString,
 	})
 
 	suite.Require().NoError(err)
 	suite.Require().NotNil(res.Info)
-	suite.Require().Equal(addr.String(), res.Info.Address)
+	suite.Require().Equal(addrString, res.Info.Address)
 	suite.Require().Nil(res.Info.PubKey)
 }