chore: rename any var to protoAny (#2986)

RegisGraptin · web-flow · commit 99c985c4ac2f · 2023-02-15T22:23:46.000+01:00
diff --git a/docs/ibc/light-clients/solomachine/concepts.md b/docs/ibc/light-clients/solomachine/concepts.md
@@ -50,7 +50,7 @@ For example:
 ```go
 data := &ClientStateData{
   Path:        []byte(path.String()),
-  ClientState: any,
+  ClientState: protoAny,
 }
 
 dataBz, err := cdc.Marshal(data)
diff --git a/docs/migrations/v4-to-v5.md b/docs/migrations/v4-to-v5.md
@@ -239,10 +239,10 @@ txMsgData := &sdk.TxMsgData{
 for i, msg := range msgs {
   // message validation
 
-  any, err := k.executeMsg(cacheCtx, msg)
+  protoAny, err := k.executeMsg(cacheCtx, msg)
   // return if err != nil
 
-  txMsgData.MsgResponses[i] = any
+  txMsgData.MsgResponses[i] = protoAny
 }
 
 // emit events
diff --git a/e2e/tests/transfer/authz_test.go b/e2e/tests/transfer/authz_test.go
@@ -59,14 +59,14 @@ func (suite *AuthzTransferTestSuite) TestAuthz_MsgTransfer_Succeeds() {
 			},
 		}
 
-		authAny, err := codectypes.NewAnyWithValue(&transferAuth)
+		protoAny, err := codectypes.NewAnyWithValue(&transferAuth)
 		suite.Require().NoError(err)
 
 		msgGrant := &authz.MsgGrant{
 			Granter: granterAddress,
 			Grantee: granteeAddress,
 			Grant: authz.Grant{
-				Authorization: authAny,
+				Authorization: protoAny,
 				// no expiration
 				Expiration: nil,
 			},
@@ -105,12 +105,12 @@ func (suite *AuthzTransferTestSuite) TestAuthz_MsgTransfer_Succeeds() {
 			TimeoutHeight: suite.GetTimeoutHeight(ctx, chainB),
 		}
 
-		transferAny, err := codectypes.NewAnyWithValue(&transferMsg)
+		protoAny, err := codectypes.NewAnyWithValue(&transferMsg)
 		suite.Require().NoError(err)
 
 		msgExec := &authz.MsgExec{
 			Grantee: granteeAddress,
-			Msgs:    []*codectypes.Any{transferAny},
+			Msgs:    []*codectypes.Any{protoAny},
 		}
 
 		resp, err := suite.BroadcastMessages(context.TODO(), chainA, granteeWallet, msgExec)
@@ -163,12 +163,12 @@ func (suite *AuthzTransferTestSuite) TestAuthz_MsgTransfer_Succeeds() {
 			TimeoutHeight: suite.GetTimeoutHeight(ctx, chainB),
 		}
 
-		transferAny, err := codectypes.NewAnyWithValue(&transferMsg)
+		protoAny, err := codectypes.NewAnyWithValue(&transferMsg)
 		suite.Require().NoError(err)
 
 		msgExec := &authz.MsgExec{
 			Grantee: granteeAddress,
-			Msgs:    []*codectypes.Any{transferAny},
+			Msgs:    []*codectypes.Any{protoAny},
 		}
 
 		resp, err := suite.BroadcastMessages(context.TODO(), chainA, granteeWallet, msgExec)
@@ -214,14 +214,14 @@ func (suite *AuthzTransferTestSuite) TestAuthz_InvalidTransferAuthorizations() {
 			},
 		}
 
-		authAny, err := codectypes.NewAnyWithValue(&transferAuth)
+		protoAny, err := codectypes.NewAnyWithValue(&transferAuth)
 		suite.Require().NoError(err)
 
 		msgGrant := &authz.MsgGrant{
 			Granter: granterAddress,
 			Grantee: granteeAddress,
 			Grant: authz.Grant{
-				Authorization: authAny,
+				Authorization: protoAny,
 				// no expiration
 				Expiration: nil,
 			},
@@ -245,12 +245,12 @@ func (suite *AuthzTransferTestSuite) TestAuthz_InvalidTransferAuthorizations() {
 				TimeoutHeight: suite.GetTimeoutHeight(ctx, chainB),
 			}
 
-			transferAny, err := codectypes.NewAnyWithValue(&transferMsg)
+			protoAny, err := codectypes.NewAnyWithValue(&transferMsg)
 			suite.Require().NoError(err)
 
 			msgExec := &authz.MsgExec{
 				Grantee: granteeAddress,
-				Msgs:    []*codectypes.Any{transferAny},
+				Msgs:    []*codectypes.Any{protoAny},
 			}
 
 			resp, err := suite.BroadcastMessages(context.TODO(), chainA, granteeWallet, msgExec)
@@ -299,12 +299,12 @@ func (suite *AuthzTransferTestSuite) TestAuthz_InvalidTransferAuthorizations() {
 				TimeoutHeight: suite.GetTimeoutHeight(ctx, chainB),
 			}
 
-			transferAny, err := codectypes.NewAnyWithValue(&transferMsg)
+			protoAny, err := codectypes.NewAnyWithValue(&transferMsg)
 			suite.Require().NoError(err)
 
 			msgExec := &authz.MsgExec{
 				Grantee: granteeAddress,
-				Msgs:    []*codectypes.Any{transferAny},
+				Msgs:    []*codectypes.Any{protoAny},
 			}
 
 			resp, err := suite.BroadcastMessages(context.TODO(), chainA, granteeWallet, msgExec)
diff --git a/modules/apps/27-interchain-accounts/host/ibc_module_test.go b/modules/apps/27-interchain-accounts/host/ibc_module_test.go
@@ -457,11 +457,11 @@ func (suite *InterchainAccountsTestSuite) TestOnRecvPacket() {
 			packetData = icaPacketData.GetBytes()
 
 			// build expected ack
-			any, err := codectypes.NewAnyWithValue(&banktypes.MsgSendResponse{})
+			protoAny, err := codectypes.NewAnyWithValue(&banktypes.MsgSendResponse{})
 			suite.Require().NoError(err)
 
 			expectedTxResponse, err := proto.Marshal(&sdk.TxMsgData{
-				MsgResponses: []*codectypes.Any{any},
+				MsgResponses: []*codectypes.Any{protoAny},
 			})
 			suite.Require().NoError(err)
 
diff --git a/modules/apps/27-interchain-accounts/host/keeper/relay.go b/modules/apps/27-interchain-accounts/host/keeper/relay.go
@@ -65,12 +65,12 @@ func (k Keeper) executeTx(ctx sdk.Context, sourcePort, destPort, destChannel str
 			return nil, err
 		}
 
-		any, err := k.executeMsg(cacheCtx, msg)
+		protoAny, err := k.executeMsg(cacheCtx, msg)
 		if err != nil {
 			return nil, err
 		}
 
-		txMsgData.MsgResponses[i] = any
+		txMsgData.MsgResponses[i] = protoAny
 	}
 
 	writeCache()
diff --git a/modules/apps/27-interchain-accounts/host/keeper/relay_test.go b/modules/apps/27-interchain-accounts/host/keeper/relay_test.go
@@ -171,11 +171,11 @@ func (suite *KeeperTestSuite) TestOnRecvPacket() {
 					Description: "tokens for all!",
 				}
 
-				any, err := codectypes.NewAnyWithValue(testProposal)
+				protoAny, err := codectypes.NewAnyWithValue(testProposal)
 				suite.Require().NoError(err)
 
 				msg := &govtypes.MsgSubmitProposal{
-					Content:        any,
+					Content:        protoAny,
 					InitialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(5000))),
 					Proposer:       interchainAccountAddr,
 				}
diff --git a/modules/apps/27-interchain-accounts/types/codec.go b/modules/apps/27-interchain-accounts/types/codec.go
@@ -69,10 +69,10 @@ func DeserializeCosmosTx(cdc codec.BinaryCodec, data []byte) ([]sdk.Msg, error)
 
 	msgs := make([]sdk.Msg, len(cosmosTx.Messages))
 
-	for i, any := range cosmosTx.Messages {
+	for i, protoAny := range cosmosTx.Messages {
 		var msg sdk.Msg
 
-		err := cdc.UnpackAny(any, &msg)
+		err := cdc.UnpackAny(protoAny, &msg)
 		if err != nil {
 			return nil, err
 		}
diff --git a/modules/apps/27-interchain-accounts/types/packet.go b/modules/apps/27-interchain-accounts/types/packet.go
@@ -54,8 +54,8 @@ func (ct CosmosTx) GetBytes() []byte {
 
 // UnpackInterfaces implements UnpackInterfacesMessage.UnpackInterfaces
 func (ct CosmosTx) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error {
-	for _, any := range ct.Messages {
-		err := unpacker.UnpackAny(any, new(sdk.Msg))
+	for _, protoAny := range ct.Messages {
+		err := unpacker.UnpackAny(protoAny, new(sdk.Msg))
 		if err != nil {
 			return err
 		}
diff --git a/modules/core/02-client/keeper/grpc_query.go b/modules/core/02-client/keeper/grpc_query.go
@@ -40,14 +40,14 @@ func (q Keeper) ClientState(c context.Context, req *types.QueryClientStateReques
 		)
 	}
 
-	any, err := types.PackClientState(clientState)
+	protoAny, err := types.PackClientState(clientState)
 	if err != nil {
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	proofHeight := types.GetSelfHeight(ctx)
 	return &types.QueryClientStateResponse{
-		ClientState: any,
+		ClientState: protoAny,
 		ProofHeight: proofHeight,
 	}, nil
 }
@@ -131,14 +131,14 @@ func (q Keeper) ConsensusState(c context.Context, req *types.QueryConsensusState
 		)
 	}
 
-	any, err := types.PackConsensusState(consensusState)
+	protoAny, err := types.PackConsensusState(consensusState)
 	if err != nil {
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	proofHeight := types.GetSelfHeight(ctx)
 	return &types.QueryConsensusStateResponse{
-		ConsensusState: any,
+		ConsensusState: protoAny,
 		ProofHeight:    proofHeight,
 	}, nil
 }
@@ -290,13 +290,13 @@ func (q Keeper) UpgradedClientState(c context.Context, req *types.QueryUpgradedC
 		)
 	}
 
-	any, err := types.PackClientState(clientState)
+	protoAny, err := types.PackClientState(clientState)
 	if err != nil {
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	return &types.QueryUpgradedClientStateResponse{
-		UpgradedClientState: any,
+		UpgradedClientState: protoAny,
 	}, nil
 }
 
@@ -320,12 +320,12 @@ func (q Keeper) UpgradedConsensusState(c context.Context, req *types.QueryUpgrad
 		)
 	}
 
-	any, err := types.PackConsensusState(consensusState)
+	protoAny, err := types.PackConsensusState(consensusState)
 	if err != nil {
 		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	return &types.QueryUpgradedConsensusStateResponse{
-		UpgradedConsensusState: any,
+		UpgradedConsensusState: protoAny,
 	}, nil
 }
diff --git a/modules/core/02-client/keeper/proposal_test.go b/modules/core/02-client/keeper/proposal_test.go
@@ -179,13 +179,13 @@ func (suite *KeeperTestSuite) TestHandleUpgradeProposal() {
 		},
 		{
 			"cannot unpack client state", func() {
-				any, err := types.PackConsensusState(&ibctm.ConsensusState{})
+				protoAny, err := types.PackConsensusState(&ibctm.ConsensusState{})
 				suite.Require().NoError(err)
 				content = &types.UpgradeProposal{
 					Title:               ibctesting.Title,
 					Description:         ibctesting.Description,
 					Plan:                plan,
-					UpgradedClientState: any,
+					UpgradedClientState: protoAny,
 				}
 			}, false,
 		},
diff --git a/modules/core/02-client/types/codec.go b/modules/core/02-client/types/codec.go
@@ -133,12 +133,12 @@ func PackClientMessage(clientMessage exported.ClientMessage) (*codectypes.Any, e
 		return nil, sdkerrors.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", clientMessage)
 	}
 
-	any, err := codectypes.NewAnyWithValue(msg)
+	protoAny, err := codectypes.NewAnyWithValue(msg)
 	if err != nil {
 		return nil, sdkerrors.Wrap(sdkerrors.ErrPackAny, err.Error())
 	}
 
-	return any, nil
+	return protoAny, nil
 }
 
 // UnpackClientMessage unpacks an Any into a ClientMessage. It returns an error if the
diff --git a/modules/core/02-client/types/codec_test.go b/modules/core/02-client/types/codec_test.go
@@ -42,14 +42,14 @@ func (suite *TypesTestSuite) TestPackClientState() {
 	testCasesAny := []caseAny{}
 
 	for _, tc := range testCases {
-		clientAny, err := types.PackClientState(tc.clientState)
+		protoAny, err := types.PackClientState(tc.clientState)
 		if tc.expPass {
 			suite.Require().NoError(err, tc.name)
 		} else {
 			suite.Require().Error(err, tc.name)
 		}
 
-		testCasesAny = append(testCasesAny, caseAny{tc.name, clientAny, tc.expPass})
+		testCasesAny = append(testCasesAny, caseAny{tc.name, protoAny, tc.expPass})
 	}
 
 	for i, tc := range testCasesAny {
@@ -89,13 +89,13 @@ func (suite *TypesTestSuite) TestPackConsensusState() {
 	testCasesAny := []caseAny{}
 
 	for _, tc := range testCases {
-		clientAny, err := types.PackConsensusState(tc.consensusState)
+		protoAny, err := types.PackConsensusState(tc.consensusState)
 		if tc.expPass {
 			suite.Require().NoError(err, tc.name)
 		} else {
 			suite.Require().Error(err, tc.name)
 		}
-		testCasesAny = append(testCasesAny, caseAny{tc.name, clientAny, tc.expPass})
+		testCasesAny = append(testCasesAny, caseAny{tc.name, protoAny, tc.expPass})
 	}
 
 	for i, tc := range testCasesAny {
@@ -135,14 +135,14 @@ func (suite *TypesTestSuite) TestPackClientMessage() {
 	testCasesAny := []caseAny{}
 
 	for _, tc := range testCases {
-		clientAny, err := types.PackClientMessage(tc.clientMessage)
+		protoAny, err := types.PackClientMessage(tc.clientMessage)
 		if tc.expPass {
 			suite.Require().NoError(err, tc.name)
 		} else {
 			suite.Require().Error(err, tc.name)
 		}
 
-		testCasesAny = append(testCasesAny, caseAny{tc.name, clientAny, tc.expPass})
+		testCasesAny = append(testCasesAny, caseAny{tc.name, protoAny, tc.expPass})
 	}
 
 	for i, tc := range testCasesAny {
diff --git a/modules/core/02-client/types/proposal.go b/modules/core/02-client/types/proposal.go
@@ -73,7 +73,7 @@ func (cup *ClientUpdateProposal) ValidateBasic() error {
 
 // NewUpgradeProposal creates a new IBC breaking upgrade proposal.
 func NewUpgradeProposal(title, description string, plan upgradetypes.Plan, upgradedClientState exported.ClientState) (govtypes.Content, error) {
-	any, err := PackClientState(upgradedClientState)
+	protoAny, err := PackClientState(upgradedClientState)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +82,7 @@ func NewUpgradeProposal(title, description string, plan upgradetypes.Plan, upgra
 		Title:               title,
 		Description:         description,
 		Plan:                plan,
-		UpgradedClientState: any,
+		UpgradedClientState: protoAny,
 	}, nil
 }
 
diff --git a/modules/core/02-client/types/proposal_test.go b/modules/core/02-client/types/proposal_test.go
@@ -148,14 +148,14 @@ func (suite *TypesTestSuite) TestUpgradeProposalValidateBasic() {
 		},
 		{
 			"failed to unpack client state", func() {
-				any, err := types.PackConsensusState(&ibctm.ConsensusState{})
+				protoAny, err := types.PackConsensusState(&ibctm.ConsensusState{})
 				suite.Require().NoError(err)
 
 				proposal = &types.UpgradeProposal{
 					Title:               ibctesting.Title,
 					Description:         ibctesting.Description,
 					Plan:                plan,
-					UpgradedClientState: any,
+					UpgradedClientState: protoAny,
 				}
 			}, false,
 		},
diff --git a/modules/core/03-connection/types/msgs.go b/modules/core/03-connection/types/msgs.go
@@ -84,10 +84,10 @@ func NewMsgConnectionOpenTry(
 	proofHeight, consensusHeight clienttypes.Height, signer string,
 ) *MsgConnectionOpenTry {
 	counterparty := NewCounterparty(counterpartyClientID, counterpartyConnectionID, counterpartyPrefix)
-	csAny, _ := clienttypes.PackClientState(counterpartyClient)
+	protoAny, _ := clienttypes.PackClientState(counterpartyClient)
 	return &MsgConnectionOpenTry{
 		ClientId:             clientID,
-		ClientState:          csAny,
+		ClientState:          protoAny,
 		Counterparty:         counterparty,
 		CounterpartyVersions: counterpartyVersions,
 		DelayPeriod:          delayPeriod,
@@ -173,11 +173,11 @@ func NewMsgConnectionOpenAck(
 	version *Version,
 	signer string,
 ) *MsgConnectionOpenAck {
-	csAny, _ := clienttypes.PackClientState(counterpartyClient)
+	protoAny, _ := clienttypes.PackClientState(counterpartyClient)
 	return &MsgConnectionOpenAck{
 		ConnectionId:             connectionID,
 		CounterpartyConnectionId: counterpartyConnectionID,
-		ClientState:              csAny,
+		ClientState:              protoAny,
 		ProofTry:                 proofTry,
 		ProofClient:              proofClient,
 		ProofConsensus:           proofConsensus,
diff --git a/modules/core/03-connection/types/msgs_test.go b/modules/core/03-connection/types/msgs_test.go
diff --git a/modules/light-clients/06-solomachine/solomachine_test.go b/modules/light-clients/06-solomachine/solomachine_test.go

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ For example:`
`50`	`50`	```go
`51`	`51`	`data := &ClientStateData{`
`52`	`52`	`Path: []byte(path.String()),`
`53`		`- ClientState: any,`
	`53`	`+ ClientState: protoAny,`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`dataBz, err := cdc.Marshal(data)`
Original file line number	Diff line number	Diff line change
`@@ -65,12 +65,12 @@ func (k Keeper) executeTx(ctx sdk.Context, sourcePort, destPort, destChannel str`
`65`	`65`	`return nil, err`
`66`	`66`	`}`
`67`	`67`
`68`		`- any, err := k.executeMsg(cacheCtx, msg)`
	`68`	`+ protoAny, err := k.executeMsg(cacheCtx, msg)`
`69`	`69`	`if err != nil {`
`70`	`70`	`return nil, err`
`71`	`71`	`}`
`72`	`72`
`73`		`- txMsgData.MsgResponses[i] = any`
	`73`	`+ txMsgData.MsgResponses[i] = protoAny`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`writeCache()`
Original file line number	Diff line number	Diff line change
`@@ -171,11 +171,11 @@ func (suite *KeeperTestSuite) TestOnRecvPacket() {`
`171`	`171`	`Description: "tokens for all!",`
`172`	`172`	`}`
`173`	`173`
`174`		`- any, err := codectypes.NewAnyWithValue(testProposal)`
	`174`	`+ protoAny, err := codectypes.NewAnyWithValue(testProposal)`
`175`	`175`	`suite.Require().NoError(err)`
`176`	`176`
`177`	`177`	`msg := &govtypes.MsgSubmitProposal{`
`178`		`- Content: any,`
	`178`	`+ Content: protoAny,`
`179`	`179`	`InitialDeposit: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(5000))),`
`180`	`180`	`Proposer: interchainAccountAddr,`
`181`	`181`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,14 +40,14 @@ func (q Keeper) ClientState(c context.Context, req *types.QueryClientStateReques`
`40`	`40`	`)`
`41`	`41`	`}`
`42`	`42`
`43`		`- any, err := types.PackClientState(clientState)`
	`43`	`+ protoAny, err := types.PackClientState(clientState)`
`44`	`44`	`if err != nil {`
`45`	`45`	`return nil, status.Error(codes.Internal, err.Error())`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`proofHeight := types.GetSelfHeight(ctx)`
`49`	`49`	`return &types.QueryClientStateResponse{`
`50`		`- ClientState: any,`
	`50`	`+ ClientState: protoAny,`
`51`	`51`	`ProofHeight: proofHeight,`
`52`	`52`	`}, nil`
`53`	`53`	`}`
`@@ -131,14 +131,14 @@ func (q Keeper) ConsensusState(c context.Context, req *types.QueryConsensusState`
`131`	`131`	`)`
`132`	`132`	`}`
`133`	`133`
`134`		`- any, err := types.PackConsensusState(consensusState)`
	`134`	`+ protoAny, err := types.PackConsensusState(consensusState)`
`135`	`135`	`if err != nil {`
`136`	`136`	`return nil, status.Error(codes.Internal, err.Error())`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`proofHeight := types.GetSelfHeight(ctx)`
`140`	`140`	`return &types.QueryConsensusStateResponse{`
`141`		`- ConsensusState: any,`
	`141`	`+ ConsensusState: protoAny,`
`142`	`142`	`ProofHeight: proofHeight,`
`143`	`143`	`}, nil`
`144`	`144`	`}`
`@@ -290,13 +290,13 @@ func (q Keeper) UpgradedClientState(c context.Context, req *types.QueryUpgradedC`
`290`	`290`	`)`
`291`	`291`	`}`
`292`	`292`
`293`		`- any, err := types.PackClientState(clientState)`
	`293`	`+ protoAny, err := types.PackClientState(clientState)`
`294`	`294`	`if err != nil {`
`295`	`295`	`return nil, status.Error(codes.Internal, err.Error())`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`return &types.QueryUpgradedClientStateResponse{`
`299`		`- UpgradedClientState: any,`
	`299`	`+ UpgradedClientState: protoAny,`
`300`	`300`	`}, nil`
`301`	`301`	`}`
`302`	`302`
`@@ -320,12 +320,12 @@ func (q Keeper) UpgradedConsensusState(c context.Context, req *types.QueryUpgrad`
`320`	`320`	`)`
`321`	`321`	`}`
`322`	`322`
`323`		`- any, err := types.PackConsensusState(consensusState)`
	`323`	`+ protoAny, err := types.PackConsensusState(consensusState)`
`324`	`324`	`if err != nil {`
`325`	`325`	`return nil, status.Error(codes.Internal, err.Error())`
`326`	`326`	`}`
`327`	`327`
`328`	`328`	`return &types.QueryUpgradedConsensusStateResponse{`
`329`		`- UpgradedConsensusState: any,`
	`329`	`+ UpgradedConsensusState: protoAny,`
`330`	`330`	`}, nil`
`331`	`331`	`}`