Should `getRecentPrioritizationFees` always return 0 as fees when an empty array is passed as parameter to it? If so, why?

Question

I wanted to use the getRecentPrioritizationFees Solana JSON-RPC method to compute a prioritization fee estimation.

According to the Solana documentation, this method has an accounts array parameter that, according to their documents, means the following:

If this parameter is provided, the response will reflect a fee to land a transaction locking all of the provided accounts as writable.

I tried this out via the https://api.mainnet-beta.solana.com cluster but got only 0 as fee values as a result when sending an empty array. Only when trying to use some accounts as parameter I could get some non-0 responses.

Based on that, I have two questions:

1. Will I always get 0-valued fees when passing an empty array? Would it be possible that there is a bug that always returns 0?
2. What exactly does it mean, from the method's documentation, that "the response will reflect a fee to land a transaction locking all of the provided accounts as writable."? Does this mean that the node will return data by looking at its priority fee cache using these accounts as keys?

Answer 1

The implementation can be a bit confusing, but it's quite short, so here's the code:

    pub fn get_prioritization_fees(&self, account_keys: &[Pubkey]) -> HashMap<Slot, u64> {
        self.cache
            .read()
            .unwrap()
            .iter()
            .filter_map(|(slot, prioritization_fee)| {
                let prioritization_fee_read = prioritization_fee.lock().unwrap();
                prioritization_fee_read.is_finalized().then(|| {
                    let mut fee = prioritization_fee_read
                        .get_min_transaction_fee()
                        .unwrap_or_default();
                    for account_key in account_keys {
                        if let Some(account_fee) =
                            prioritization_fee_read.get_writable_account_fee(account_key)
                        {
                            fee = std::cmp::max(fee, account_fee);
                        }
                    }
                    Some((*slot, fee))
                })
            })
            .flatten()
            .collect()
    }

To answer your questions:

1. Because of let mut fee = prioritization_fee_read.get_min_transaction_fee().unwrap_or_default();, with an empty array, you'll at least the get minimal transaction fee that landed on the network.

2. Yep that's exactly it! Right now it's just using a simple max of all fees, but you could imagine this getting more sophisticated as transactions lock many accounts.

Here's the code for reference: https://github.com/solana-labs/solana/blob/13107b4eb69120f672896f48d77affa9df45e8b4/runtime/src/prioritization_fee_cache.rs#L364