Too many nested async methods. Is that a problem?

The following code gets a list of investments belonging to a customer from 3 different resources. The flow starts with a controller's call and follows the flow described below where all methods are declared as async and called with await operator.

I'm wondering if is there a problem making all methods as async. Is there any performance penalty? Is it a code smell or an anti-pattern?

I know there are things that must be waited like access url, get data from cahce, etc. But I think there are things like filling a list or sum some few values doesn't need to be async.

Below follow the code (some parts where ommited for clearness):

Controller

    {HttpGet]
    public async Task<IActionResult> Get()
    {
        Client client = await _mediator.Send(new RecuperarInvestimentosQuery());
        return Ok(cliente);
    }

QueryHandler

    public async Task<Client> Handle(RecoverInvestimentsQuery request, CancellationToken cancellationToken)
    {
        Client client;
        List<Investiment> list = await _investimentBuilder.GetInvestiments();
        client = new Cliente(request.Id, list);
        return client;
    }

InvestmentBuilder

    public async Task<List<Investiment>> GetInvestiments()
    {
        ListInvestiments builder = new ListInvestiments();
        await builder.BuildLists(_builder);
        // here I get the List<Investiment> list already fulfilled to return to the controller
        return list;
    }

BuildLists

    public async Task BuildLists(IBuilder builder)
    {
        Task[] tasks = new Task[] {
            builder.GetFundsAsync(),   //****
            builder.ObterTesouro(),
            builder.ObterRendaFixa()
        };
        await Task.WhenAll(tasks);
    }

Funds, Bonds and Fixed Income Services (***all 3 methods are equal, only its name vary, so I just put one of them for the sake of saving space)

    public async Task GetFundsAsync()
    {
        var listOfFunds = await _FundsService.RecoverFundsAsync();
        // listOfFunds will get all items from all types of investments
    }

Recover Funds, Bonds and Fixed Incomes methods are equals too, again I just put one of them

    public async Task<List<Funds>> RecoverFundsAsync()
    {
        var returnCache = await _clientCache.GetValueAsync("fundsService");
        // if not in cache, so go get from url
        if (returnCache == null)
        {
            string url = _configuration.GetValue<string>("Urls:Funds");
            var response = await _clienteHttp.ObterDadosAsync(url);
            if (response != null)
            {
                string funds = JObject.Parse(response).SelectToken("funds").ToString();
                await _clienteCache.SetValueAsync("fundService", funds);
                return JsonConvert.DeserializeObject<List<Funds>>(fundos);
            }
            else
                return null;
        }
        return JsonConvert.DeserializeObject<List<Funds>>(returnCache);
    }

HTTP Client

    public async Task<string> GetDataAsync(string Url)
    {
        using (HttpClient client = _clientFactory.CreateClient())
        {
            var response = await client.GetAsync(Url);
            if (response.IsSuccessStatusCode)
                return await response.Content.ReadAsStringAsync();
            else
                return null;
        }
    }

Cache Client

    public async Task<string> GetValueAsync(string key)
    {
        IDatabase cache = Connection.GetDatabase();
        RedisValue value = await cache.StringGetAsync(key);
        if (value.HasValue)
            return value.ToString();
        else
            return null;
    }

Could someone give a thought about that?

Thanks in advance.