massa_grpc/
public.rs

1// Copyright (c) 2023 MASSA LABS <info@massa.net>
2
3use crate::error::GrpcError;
4use crate::server::MassaPublicGrpc;
5use crate::{EndorsementDraw, SlotDraw, SlotRange};
6
7use itertools::{izip, Itertools};
8use massa_execution_exports::mapping_grpc::{
9    to_event_filter, to_execution_query_response, to_querystate_filter,
10};
11use massa_execution_exports::{
12    ExecutionQueryRequest, ExecutionQueryRequestItem, ExecutionQueryResponseItem,
13    ExecutionStackElement, ReadOnlyExecutionRequest, ReadOnlyExecutionTarget,
14};
15use massa_models::address::Address;
16use massa_models::amount::Amount;
17use massa_models::block::{Block, BlockGraphStatus};
18use massa_models::block_id::BlockId;
19use massa_models::config::CompactConfig;
20use massa_models::datastore::DatastoreDeserializer;
21use massa_models::endorsement::{EndorsementId, SecureShareEndorsement};
22use massa_models::operation::{OperationId, SecureShareOperation};
23use massa_models::prehash::{PreHashMap, PreHashSet};
24use massa_models::slot::Slot;
25use massa_models::timeslots::get_latest_block_slot_at_timestamp;
26use massa_proto_rs::massa::api::v1::{self as grpc_api};
27use massa_proto_rs::massa::model::v1::{self as grpc_model, read_only_execution_call};
28use massa_serialization::{DeserializeError, Deserializer};
29use massa_time::MassaTime;
30use massa_versioning::versioning_factory::{FactoryStrategy, VersioningFactory};
31use std::collections::HashSet;
32use std::str::FromStr;
33
34#[cfg(feature = "execution-trace")]
35use massa_execution_exports::types_trace_info::AbiTrace;
36#[cfg(feature = "execution-trace")]
37use massa_proto_rs::massa::api::v1::abi_call_stack_element_parent::CallStackElement;
38#[cfg(feature = "execution-trace")]
39use massa_proto_rs::massa::api::v1::{
40    AbiCallStack, AbiCallStackElement, AbiCallStackElementCall, AbiCallStackElementParent,
41    AscabiCallStack, DeferredCallAbiCallStack, GetOperationAbiCallStacksResponse,
42    GetSlotAbiCallStacksResponse, OperationAbiCallStack, SlotAbiCallStacks, TransferInfo,
43    TransferInfos,
44};
45
46/// Execute read only call (function or bytecode)
47pub(crate) async fn execute_read_only_call(
48    grpc: &MassaPublicGrpc,
49    request: tonic::Request<grpc_api::ExecuteReadOnlyCallRequest>,
50) -> Result<grpc_api::ExecuteReadOnlyCallResponse, GrpcError> {
51    let call: grpc_model::ReadOnlyExecutionCall = request
52        .into_inner()
53        .call
54        .ok_or_else(|| GrpcError::InvalidArgument("no call provided".to_string()))?;
55
56    let caller_address = match call.caller_address {
57        Some(addr) => Address::from_str(&addr)?,
58        None => {
59            let now = MassaTime::now();
60            let keypair = grpc.keypair_factory.create(&(), FactoryStrategy::At(now))?;
61            Address::from_public_key(&keypair.get_public_key())
62        }
63    };
64
65    let mut call_stack = Vec::new();
66    let mut coins = None;
67    let target = if let Some(call_target) = call.target {
68        match call_target {
69            read_only_execution_call::Target::BytecodeCall(value) => {
70                let op_datastore = if value.operation_datastore.is_empty() {
71                    None
72                } else {
73                    let deserializer = DatastoreDeserializer::new(
74                        grpc.grpc_config.max_op_datastore_entry_count,
75                        grpc.grpc_config.max_op_datastore_key_length,
76                        grpc.grpc_config.max_op_datastore_value_length,
77                    );
78                    match deserializer.deserialize::<DeserializeError>(&value.operation_datastore) {
79                        Ok((_, deserialized)) => Some(deserialized),
80                        Err(e) => {
81                            return Err(GrpcError::InvalidArgument(format!(
82                                "Datastore deserializing error: {}",
83                                e
84                            )))
85                        }
86                    }
87                };
88
89                call_stack.push(ExecutionStackElement {
90                    address: caller_address,
91                    coins: Default::default(),
92                    owned_addresses: vec![caller_address],
93                    operation_datastore: op_datastore,
94                });
95
96                ReadOnlyExecutionTarget::BytecodeExecution(value.bytecode)
97            }
98            read_only_execution_call::Target::FunctionCall(call) => {
99                let target_address = Address::from_str(&call.target_address)?;
100
101                coins = call
102                    .coins
103                    .map(|native_amount| {
104                        Amount::from_mantissa_scale(native_amount.mantissa, native_amount.scale)
105                            .map_err(|_| GrpcError::InvalidArgument("invalid amount".to_string()))
106                    })
107                    .transpose()?;
108
109                call_stack.push(ExecutionStackElement {
110                    address: caller_address,
111                    coins: Default::default(),
112                    owned_addresses: vec![caller_address],
113                    operation_datastore: None, // should always be None
114                });
115                // propagate the request-provided coins to the target stack element
116                // so that get_call_coins matches the JSON-RPC behavior
117                call_stack.push(ExecutionStackElement {
118                    address: target_address,
119                    coins: coins.unwrap_or_default(),
120                    owned_addresses: vec![target_address],
121                    operation_datastore: None, // should always be None
122                });
123
124                ReadOnlyExecutionTarget::FunctionCall {
125                    target_addr: Address::from_str(&call.target_address)?,
126                    target_func: call.target_function,
127                    parameter: call.parameter,
128                }
129            }
130        }
131    } else {
132        return Err(GrpcError::InvalidArgument(
133            "no call target provided".to_string(),
134        ));
135    };
136
137    let read_only_call = ReadOnlyExecutionRequest {
138        max_gas: call.max_gas,
139        call_stack,
140        target,
141        coins,
142        fee: call
143            .fee
144            .map(|native_amount| {
145                Amount::from_mantissa_scale(native_amount.mantissa, native_amount.scale)
146                    .map_err(|_| GrpcError::InvalidArgument("invalid amount".to_string()))
147            })
148            .transpose()?,
149    };
150
151    // check if fee is provided and if it is too low
152    if call.fee.is_some()
153        && read_only_call
154            .fee
155            .unwrap_or_default()
156            .checked_sub(grpc.grpc_config.minimal_fees)
157            .is_none()
158    {
159        return Err(GrpcError::InvalidArgument(format!(
160            "fee is too low provided: {} , minimal_fees required: {}",
161            read_only_call.fee.unwrap_or_default(),
162            grpc.grpc_config.minimal_fees
163        )));
164    }
165
166    // await the answer without holding a runtime thread
167    let output = grpc
168        .execution_controller
169        .execute_readonly_request_async(read_only_call)
170        .await?;
171
172    let result = grpc_model::ReadOnlyExecutionOutput {
173        out: Some(output.out.into()),
174        used_gas: output.gas_cost,
175        call_result: output.call_result,
176    };
177
178    Ok(grpc_api::ExecuteReadOnlyCallResponse {
179        output: Some(result),
180    })
181}
182
183/// Get blocks
184pub(crate) fn get_blocks(
185    grpc: &MassaPublicGrpc,
186    request: tonic::Request<grpc_api::GetBlocksRequest>,
187) -> Result<grpc_api::GetBlocksResponse, GrpcError> {
188    let ids = request.into_inner().block_ids;
189
190    if ids.is_empty() {
191        return Err(GrpcError::InvalidArgument(
192            "no block id provided".to_string(),
193        ));
194    }
195
196    if ids.len() as u32 > grpc.grpc_config.max_block_ids_per_request {
197        return Err(GrpcError::InvalidArgument(format!(
198            "too many block ids received. Only a maximum of {} block ids are accepted per request",
199            grpc.grpc_config.max_block_ids_per_request
200        )));
201    }
202
203    let mut block_ids: Vec<BlockId> = ids
204        .into_iter()
205        .map(|id| {
206            BlockId::from_str(id.as_str())
207                .map_err(|_| GrpcError::InvalidArgument(format!("invalid block id: {}", id)))
208        })
209        .collect::<Result<_, _>>()?;
210
211    let mut blocks: Vec<Block> = Vec::with_capacity(block_ids.len());
212    {
213        let block_storage_lock = grpc.storage.read_blocks();
214        block_ids.retain(|id| {
215            if let Some(wrapped_block) = block_storage_lock.get(id) {
216                blocks.push(wrapped_block.content.clone());
217                return true;
218            };
219            false
220        });
221    }
222
223    let block_statuses = grpc.consensus_controller.get_block_statuses(&block_ids);
224
225    let result = blocks
226        .into_iter()
227        .zip(block_statuses)
228        .map(|(block, block_graph_status)| grpc_model::BlockWrapper {
229            block: Some(block.into()),
230            status: block_graph_status.into(),
231        })
232        .collect();
233
234    Ok(grpc_api::GetBlocksResponse {
235        wrapped_blocks: result,
236    })
237}
238
239/// Get multiple datastore entries
240pub(crate) fn get_datastore_entries(
241    grpc: &MassaPublicGrpc,
242    request: tonic::Request<grpc_api::GetDatastoreEntriesRequest>,
243) -> Result<grpc_api::GetDatastoreEntriesResponse, GrpcError> {
244    let inner_req = request.into_inner();
245
246    // return error if entry are empty
247    if inner_req.filters.is_empty() {
248        return Err(GrpcError::InvalidArgument("no filter provided".to_string()));
249    }
250
251    // return error if entry are too many filters for a single request
252    if inner_req.filters.len() as u64 > grpc.grpc_config.max_datastore_entries_per_request {
253        return Err(GrpcError::InvalidArgument(format!(
254            "too many datastore entries received. Only a maximum of {} datastore entries are accepted per request",
255            grpc.grpc_config.max_datastore_entries_per_request
256        )));
257    }
258
259    let filters: Vec<(Address, Vec<u8>)> = inner_req
260        .filters
261        .into_iter()
262        .map(|filter| {
263            let filter = filter
264                .filter
265                .ok_or_else(|| GrpcError::InvalidArgument("no filter provided".to_string()))?;
266            match filter {
267                grpc_api::get_datastore_entry_filter::Filter::AddressKey(addrs) => {
268                    let add = Address::from_str(&addrs.address).map_err(|_| {
269                        GrpcError::InvalidArgument(format!("invalid address: {}", addrs.address))
270                    })?;
271                    Ok((add, addrs.key))
272                }
273            }
274        })
275        .collect::<Result<Vec<(Address, Vec<u8>)>, GrpcError>>()?;
276
277    let entries = grpc
278        .execution_controller
279        .get_final_and_active_data_entry(filters)
280        .into_iter()
281        .map(|output| grpc_model::DatastoreEntry {
282            final_value: output.0.unwrap_or_default(),
283            candidate_value: output.1.unwrap_or_default(),
284        })
285        .collect();
286
287    Ok(grpc_api::GetDatastoreEntriesResponse {
288        datastore_entries: entries,
289    })
290}
291
292/// Get endorsements
293pub(crate) fn get_endorsements(
294    grpc: &MassaPublicGrpc,
295    request: tonic::Request<grpc_api::GetEndorsementsRequest>,
296) -> Result<grpc_api::GetEndorsementsResponse, GrpcError> {
297    let ids = request.into_inner().endorsement_ids;
298
299    if ids.is_empty() {
300        return Err(GrpcError::InvalidArgument(
301            "no endorsement id provided".to_string(),
302        ));
303    }
304
305    if ids.len() as u32 > grpc.grpc_config.max_endorsement_ids_per_request {
306        return Err(GrpcError::InvalidArgument(format!(
307            "too many endorsement ids received. Only a maximum of {} endorsement ids are accepted per request",
308            grpc.grpc_config.max_endorsement_ids_per_request
309        )));
310    }
311
312    let mut endorsement_ids: Vec<EndorsementId> = ids
313        .into_iter()
314        .map(|id| {
315            EndorsementId::from_str(id.as_str())
316                .map_err(|_| GrpcError::InvalidArgument(format!("invalid endorsement id: {}", id)))
317        })
318        .collect::<Result<_, _>>()?;
319
320    let mut secure_share_endorsements: Vec<SecureShareEndorsement> =
321        Vec::with_capacity(endorsement_ids.len());
322    {
323        let endorsement_storage_lock = grpc.storage.read_endorsements();
324        endorsement_ids.retain(|id| {
325            if let Some(wrapped_endorsement) = endorsement_storage_lock.get(id) {
326                secure_share_endorsements.push(wrapped_endorsement.clone());
327                return true;
328            };
329            false
330        });
331    }
332
333    let storage_info: Vec<(SecureShareEndorsement, PreHashSet<BlockId>)> = {
334        let read_blocks = grpc.storage.read_blocks();
335        secure_share_endorsements
336            .into_iter()
337            .map(|secure_share_operation| {
338                let ed_id = secure_share_operation.id;
339                (
340                    secure_share_operation,
341                    read_blocks
342                        .get_blocks_by_endorsement(&ed_id)
343                        .cloned()
344                        .unwrap_or_default(),
345                )
346            })
347            .collect()
348    };
349
350    // ask pool whether it carries the endorsements
351    let in_pool = grpc
352        .pool_controller
353        .contains_endorsements(
354            &endorsement_ids,
355            Some(MassaTime::from_millis(
356                grpc.grpc_config.timeout.as_millis() as u64
357            )),
358        )
359        .unwrap_or_else(|_| vec![false; endorsement_ids.len()]);
360
361    // check finality by cross-referencing Consensus and looking for final blocks that contain the endorsement
362    let is_final: Vec<bool> = {
363        let involved_blocks: Vec<BlockId> = storage_info
364            .iter()
365            .flat_map(|(_ed, bs)| bs.iter())
366            .unique()
367            .cloned()
368            .collect();
369
370        let involved_block_statuses = grpc
371            .consensus_controller
372            .get_block_statuses(&involved_blocks);
373
374        let block_statuses: PreHashMap<BlockId, BlockGraphStatus> = involved_blocks
375            .into_iter()
376            .zip(involved_block_statuses)
377            .collect();
378
379        storage_info
380            .iter()
381            .map(|(_ed, bs)| {
382                bs.iter()
383                    .any(|b| block_statuses.get(b) == Some(&BlockGraphStatus::Final))
384            })
385            .collect()
386    };
387
388    // gather all values into a vector of EndorsementInfo instances
389    let mut result: Vec<grpc_model::EndorsementWrapper> = Vec::with_capacity(endorsement_ids.len());
390    let zipped_iterator = izip!(
391        storage_info.into_iter(),
392        in_pool.into_iter(),
393        is_final.into_iter()
394    );
395
396    for ((endorsement, in_blocks), in_pool, is_final) in zipped_iterator {
397        result.push(grpc_model::EndorsementWrapper {
398            in_pool,
399            is_final,
400            in_blocks: in_blocks
401                .into_iter()
402                .map(|block_id| block_id.to_string())
403                .collect(),
404            endorsement: Some(endorsement.into()),
405        });
406    }
407
408    Ok(grpc_api::GetEndorsementsResponse {
409        wrapped_endorsements: result,
410    })
411}
412
413/// Get the stakers
414pub(crate) fn get_stakers(
415    grpc: &MassaPublicGrpc,
416    request: tonic::Request<grpc_api::GetStakersRequest>,
417) -> Result<grpc_api::GetStakersResponse, GrpcError> {
418    let inner_req = request.into_inner();
419
420    // min_roll, max_roll, limit
421    let mut filter_opt = (None, None, None);
422
423    // Parse the query parameters, if provided.
424    inner_req
425        .filters
426        .iter()
427        .for_each(|filter| match filter.filter {
428            Some(grpc_api::stakers_filter::Filter::MinRolls(min_rolls)) => {
429                filter_opt.0 = Some(min_rolls);
430            }
431            Some(grpc_api::stakers_filter::Filter::MaxRolls(max_rolls)) => {
432                filter_opt.1 = Some(max_rolls);
433            }
434            Some(grpc_api::stakers_filter::Filter::Limit(limit)) => {
435                filter_opt.2 = Some(limit);
436            }
437            None => {}
438        });
439
440    // Get the current cycle and slot.
441    let now: MassaTime = MassaTime::now();
442
443    let latest_block_slot_at_timestamp_result = get_latest_block_slot_at_timestamp(
444        grpc.grpc_config.thread_count,
445        grpc.grpc_config.t0,
446        grpc.grpc_config.genesis_timestamp,
447        now,
448    );
449
450    let (cur_cycle, _cur_slot) = match latest_block_slot_at_timestamp_result {
451        Ok(Some(cur_slot)) if cur_slot.period <= grpc.grpc_config.last_start_period => (
452            Slot::new(grpc.grpc_config.last_start_period, 0)
453                .get_cycle(grpc.grpc_config.periods_per_cycle),
454            cur_slot,
455        ),
456        Ok(Some(cur_slot)) => (
457            cur_slot.get_cycle(grpc.grpc_config.periods_per_cycle),
458            cur_slot,
459        ),
460        Ok(None) => (0, Slot::new(0, 0)),
461        Err(e) => return Err(GrpcError::ModelsError(e)),
462    };
463
464    // Get the list of stakers, filtered by the specified minimum and maximum roll counts.
465    let mut staker_vec = grpc
466        .execution_controller
467        .get_cycle_active_rolls(cur_cycle)
468        .into_iter()
469        .filter_map(|(addr, rolls)| {
470            if let Some(min_rolls) = filter_opt.0 {
471                if rolls < min_rolls {
472                    return None;
473                }
474            }
475            if let Some(max_rolls) = filter_opt.1 {
476                if rolls > max_rolls {
477                    return None;
478                }
479            }
480            Some((addr.to_string(), rolls))
481        })
482        .collect::<Vec<(String, u64)>>();
483
484    // Sort the stakers by their roll counts in descending order.
485    staker_vec.sort_by_key(|&(_, roll_counts)| std::cmp::Reverse(roll_counts));
486
487    if let Some(limit) = filter_opt.2 {
488        staker_vec = staker_vec
489            .into_iter()
490            .take(limit as usize)
491            .collect::<Vec<(String, u64)>>();
492    }
493
494    let stakers = staker_vec
495        .into_iter()
496        .map(|(address, rolls)| grpc_model::StakerEntry { address, rolls })
497        .collect();
498
499    Ok(grpc_api::GetStakersResponse { stakers })
500}
501
502#[cfg(feature = "execution-trace")]
503/// recursive function to convert a AbiTrace struct
504pub fn into_element(abi_trace: &AbiTrace) -> AbiCallStackElementParent {
505    if abi_trace.sub_calls.is_none() {
506        AbiCallStackElementParent {
507            call_stack_element: Some(CallStackElement::Element(AbiCallStackElement {
508                name: abi_trace.name.clone(),
509                parameters: abi_trace
510                    .parameters
511                    .iter()
512                    .map(|p| serde_json::to_string(p).unwrap_or_default())
513                    .collect::<Vec<String>>(),
514                return_value: serde_json::to_string(&abi_trace.return_value).unwrap_or_default(),
515            })),
516        }
517    } else {
518        AbiCallStackElementParent {
519            call_stack_element: Some(CallStackElement::ElementCall(AbiCallStackElementCall {
520                name: abi_trace.name.clone(),
521                parameters: abi_trace
522                    .parameters
523                    .iter()
524                    .map(|p| serde_json::to_string(p).unwrap_or_default())
525                    .collect(),
526                return_value: serde_json::to_string(&abi_trace.return_value).unwrap_or_default(),
527                sub_calls: abi_trace
528                    .sub_calls
529                    .clone()
530                    .unwrap_or_default()
531                    .iter()
532                    .map(into_element)
533                    .collect(),
534            })),
535        }
536    }
537}
538
539#[cfg(feature = "execution-trace")]
540/// Get slot transfers
541pub(crate) fn get_slot_transfers(
542    grpc: &MassaPublicGrpc,
543    request: tonic::Request<grpc_api::GetSlotTransfersRequest>,
544) -> Result<grpc_api::GetSlotTransfersResponse, GrpcError> {
545    use massa_proto_rs::massa::api::v1::GetSlotTransfersResponse;
546
547    let slots = request.into_inner().slots;
548
549    let mut transfer_each_slot: Vec<TransferInfos> = vec![];
550    for slot in slots {
551        let mut slot_transfers = TransferInfos {
552            slot: slot.clone().into(),
553            transfers: vec![],
554        };
555        // Read the ABI call stack and the direct transfers for this slot from a single
556        // consistent snapshot, so the combined response cannot mix data from two different
557        // executions of the same slot (a re-execution between two separate reads).
558        let (abi_calls, direct_transfers) = grpc
559            .execution_controller
560            .get_slot_abi_call_stack_and_transfers(slot.clone().into());
561        if let Some(abi_calls) = abi_calls {
562            // flatten & filter transfer trace in asc_call_stacks
563
564            let abi_transfer_1 = "assembly_script_transfer_coins".to_string();
565            let abi_transfer_2 = "assembly_script_transfer_coins_for".to_string();
566            let transfer_abi_names = vec![abi_transfer_1, abi_transfer_2];
567            for (i, asc_call_stack) in abi_calls.asc_call_stacks.iter().enumerate() {
568                for abi_trace in asc_call_stack {
569                    let only_transfer = abi_trace.flatten_filter(&transfer_abi_names);
570                    for transfer in only_transfer {
571                        let (t_from, t_to, t_amount) = transfer.parse_transfer();
572                        slot_transfers.transfers.push(TransferInfo {
573                            from: t_from.clone(),
574                            to: t_to.clone(),
575                            amount: t_amount,
576                            operation_id_or_asc_index: Some(
577                                grpc_api::transfer_info::OperationIdOrAscIndex::AscIndex(i as u64),
578                            ),
579                        });
580                    }
581                }
582            }
583
584            for op_call_stack in abi_calls.operation_call_stacks {
585                let op_id = op_call_stack.0;
586                let op_call_stack = op_call_stack.1;
587                for abi_trace in op_call_stack {
588                    let only_transfer = abi_trace.flatten_filter(&transfer_abi_names);
589                    for transfer in only_transfer {
590                        let (t_from, t_to, t_amount) = transfer.parse_transfer();
591                        slot_transfers.transfers.push(TransferInfo {
592                            from: t_from.clone(),
593                            to: t_to.clone(),
594                            amount: t_amount,
595                            operation_id_or_asc_index: Some(
596                                grpc_api::transfer_info::OperationIdOrAscIndex::OperationId(
597                                    op_id.to_string(),
598                                ),
599                            ),
600                        });
601                    }
602                }
603            }
604        }
605
606        if let Some(transfers) = direct_transfers {
607            for transfer in transfers {
608                slot_transfers.transfers.push(TransferInfo {
609                    from: transfer.from.to_string(),
610                    to: transfer.to.to_string(),
611                    amount: transfer.amount.to_raw(),
612                    operation_id_or_asc_index: Some(
613                        grpc_api::transfer_info::OperationIdOrAscIndex::OperationId(
614                            transfer.op_id.to_string(),
615                        ),
616                    ),
617                });
618            }
619        }
620
621        transfer_each_slot.push(slot_transfers);
622    }
623
624    Ok(GetSlotTransfersResponse { transfer_each_slot })
625}
626
627#[cfg(feature = "execution-trace")]
628/// Get operation ABI call stacks
629pub(crate) fn get_operation_abi_call_stacks(
630    grpc: &MassaPublicGrpc,
631    request: tonic::Request<grpc_api::GetOperationAbiCallStacksRequest>,
632) -> Result<grpc_api::GetOperationAbiCallStacksResponse, GrpcError> {
633    let op_ids_ = request.into_inner().operation_ids;
634
635    let op_ids: Vec<OperationId> = op_ids_
636        .iter()
637        .map(|o| OperationId::from_str(o))
638        .collect::<Result<Vec<_>, _>>()?;
639
640    let mut elements = vec![];
641    for op_id in op_ids {
642        let abi_traces_ = grpc
643            .execution_controller
644            .get_operation_abi_call_stack(op_id);
645        if let Some(abi_traces) = abi_traces_ {
646            for abi_trace in abi_traces.iter() {
647                elements.push(into_element(abi_trace));
648            }
649        } else {
650            elements.push(AbiCallStackElementParent {
651                call_stack_element: None,
652            })
653        }
654    }
655
656    let resp = GetOperationAbiCallStacksResponse {
657        call_stacks: vec![AbiCallStack {
658            call_stack: elements,
659        }],
660    };
661
662    Ok(resp)
663}
664
665#[cfg(feature = "execution-trace")]
666pub(crate) fn get_slot_abi_call_stacks(
667    grpc: &MassaPublicGrpc,
668    request: tonic::Request<grpc_api::GetSlotAbiCallStacksRequest>,
669) -> Result<grpc_api::GetSlotAbiCallStacksResponse, GrpcError> {
670    let slots = request.into_inner().slots;
671
672    let mut slot_elements = vec![];
673    for slot in slots {
674        let call_stack_ = grpc
675            .execution_controller
676            .get_slot_abi_call_stack(slot.into());
677
678        let mut slot_abi_call_stacks = SlotAbiCallStacks {
679            asc_call_stacks: vec![],
680            deferred_call_stacks: vec![],
681            operation_call_stacks: vec![],
682        };
683
684        if let Some(call_stack) = call_stack_ {
685            for (call_id, deferred_call_stack) in call_stack.deferred_call_stacks {
686                slot_abi_call_stacks
687                    .deferred_call_stacks
688                    .push(DeferredCallAbiCallStack {
689                        deferred_call_id: call_id.to_string(),
690                        call_stack: deferred_call_stack.iter().map(into_element).collect(),
691                    })
692            }
693            for (i, asc_call_stack) in call_stack.asc_call_stacks.into_iter().enumerate() {
694                slot_abi_call_stacks.asc_call_stacks.push(AscabiCallStack {
695                    index: i as u64,
696                    call_stack: asc_call_stack.iter().map(into_element).collect(),
697                })
698            }
699            for (op_id, op_call_stack) in call_stack.operation_call_stacks {
700                slot_abi_call_stacks
701                    .operation_call_stacks
702                    .push(OperationAbiCallStack {
703                        operation_id: op_id.to_string(),
704                        call_stack: op_call_stack.iter().map(into_element).collect(),
705                    })
706            }
707        }
708        slot_elements.push(slot_abi_call_stacks);
709    }
710
711    let resp = GetSlotAbiCallStacksResponse {
712        slot_call_stacks: slot_elements,
713    };
714
715    Ok(resp)
716}
717
718/// Get next block best parents
719pub(crate) fn get_next_block_best_parents(
720    grpc: &MassaPublicGrpc,
721    _request: tonic::Request<grpc_api::GetNextBlockBestParentsRequest>,
722) -> Result<grpc_api::GetNextBlockBestParentsResponse, GrpcError> {
723    let block_parents = grpc
724        .consensus_controller
725        .get_best_parents()
726        .into_iter()
727        .map(|p| grpc_model::BlockParent {
728            block_id: p.0.to_string(),
729            period: p.1,
730        })
731        .collect();
732    Ok(grpc_api::GetNextBlockBestParentsResponse { block_parents })
733}
734
735/// Get operations
736pub(crate) fn get_operations(
737    grpc: &MassaPublicGrpc,
738    request: tonic::Request<grpc_api::GetOperationsRequest>,
739) -> Result<grpc_api::GetOperationsResponse, GrpcError> {
740    let operation_ids = request.into_inner().operation_ids;
741
742    if operation_ids.is_empty() {
743        return Err(GrpcError::InvalidArgument(
744            "no operations ids specified".to_string(),
745        ));
746    }
747
748    if operation_ids.len() as u32 > grpc.grpc_config.max_operation_ids_per_request {
749        return Err(GrpcError::InvalidArgument(format!("too many operations received. Only a maximum of {} operations are accepted per request", grpc.grpc_config.max_operation_ids_per_request)));
750    }
751
752    let operation_ids: Vec<OperationId> = operation_ids
753        .into_iter()
754        .map(|id| {
755            OperationId::from_str(id.as_str())
756                .map_err(|_| GrpcError::InvalidArgument(format!("invalid operation id: {}", id)))
757        })
758        .collect::<Result<_, _>>()?;
759
760    let secure_share_operations: Vec<SecureShareOperation> = {
761        let read_ops = grpc.storage.read_operations();
762        operation_ids
763            .iter()
764            .filter_map(|id| read_ops.get(id).cloned())
765            .collect()
766    };
767
768    let storage_info: Vec<(SecureShareOperation, PreHashSet<BlockId>)> = {
769        let read_blocks = grpc.storage.read_blocks();
770        secure_share_operations
771            .into_iter()
772            .map(|secure_share_operation| {
773                let op_id = secure_share_operation.id;
774                (
775                    secure_share_operation,
776                    read_blocks
777                        .get_blocks_by_operation(&op_id)
778                        .cloned()
779                        .unwrap_or_default(),
780                )
781            })
782            .collect()
783    };
784
785    let operations: Vec<grpc_model::OperationWrapper> = storage_info
786        .into_iter()
787        .map(|secure_share| {
788            let (secure_share_operation, block_ids) = secure_share;
789            grpc_model::OperationWrapper {
790                thread: secure_share_operation
791                    .content_creator_address
792                    .get_thread(grpc.grpc_config.thread_count) as u32,
793                operation: Some(secure_share_operation.into()),
794                block_ids: block_ids.into_iter().map(|id| id.to_string()).collect(),
795            }
796        })
797        .collect();
798
799    Ok(grpc_api::GetOperationsResponse {
800        wrapped_operations: operations,
801    })
802}
803
804/// Get smart contract execution events
805pub(crate) fn get_sc_execution_events(
806    grpc: &MassaPublicGrpc,
807    request: tonic::Request<grpc_api::GetScExecutionEventsRequest>,
808) -> Result<grpc_api::GetScExecutionEventsResponse, GrpcError> {
809    let event_filter = to_event_filter(request.into_inner().filters)?;
810    // go through query_state so that the event count and response size budgets apply
811    let response = grpc
812        .execution_controller
813        .query_state(ExecutionQueryRequest {
814            requests: vec![ExecutionQueryRequestItem::Events(event_filter)],
815            max_response_size: grpc.grpc_config.max_encoding_message_size,
816            max_event_count: Some(grpc.grpc_config.max_event_per_query as usize),
817            query_state_deadline_ms: grpc.grpc_config.query_state_deadline_ms,
818        });
819    let events: Vec<grpc_model::ScExecutionEvent> = match response.responses.into_iter().next() {
820        Some(Ok(ExecutionQueryResponseItem::Events(events))) => {
821            events.into_iter().map(|event| event.into()).collect()
822        }
823        Some(Err(err)) => return Err(GrpcError::InternalServerError(err.to_string())),
824        _ => {
825            return Err(GrpcError::InternalServerError(
826                "unexpected response type".to_string(),
827            ))
828        }
829    };
830
831    Ok(grpc_api::GetScExecutionEventsResponse { events })
832}
833
834//  Get selector draws
835pub(crate) fn get_selector_draws(
836    grpc: &MassaPublicGrpc,
837    request: tonic::Request<grpc_api::GetSelectorDrawsRequest>,
838) -> Result<grpc_api::GetSelectorDrawsResponse, GrpcError> {
839    let inner_req = request.into_inner();
840    if inner_req.filters.len() as u32 > grpc.grpc_config.max_filters_per_request {
841        return Err(GrpcError::InvalidArgument(format!(
842            "too many filters received. Only a maximum of {} filters are accepted per request",
843            grpc.grpc_config.max_filters_per_request
844        )));
845    }
846
847    let mut addresses_filter: Option<PreHashSet<Address>> = None;
848    let mut slot_ranges_filter: Option<HashSet<SlotRange>> = None;
849    // Get params filter from the request.
850    for query in inner_req.filters.into_iter() {
851        if let Some(filter) = query.filter {
852            match filter {
853                grpc_api::selector_draws_filter::Filter::Addresses(addrs) => {
854                    if addrs.addresses.len() as u32 > grpc.grpc_config.max_addresses_per_request {
855                        return Err(GrpcError::InvalidArgument(format!(
856                            "too many addresses received. Only a maximum of {} addresses are accepted per request",
857                            grpc.grpc_config.max_addresses_per_request
858                        )));
859                    }
860                    let addresses = addresses_filter.get_or_insert_with(PreHashSet::default);
861                    for address in addrs.addresses {
862                        addresses.insert(Address::from_str(&address).map_err(|_| {
863                            GrpcError::InvalidArgument(format!("invalid address: {}", address))
864                        })?);
865                    }
866                }
867                grpc_api::selector_draws_filter::Filter::SlotRange(s_range) => {
868                    let slot_ranges = slot_ranges_filter.get_or_insert_with(HashSet::new);
869                    if slot_ranges.len() as u32 >= grpc.grpc_config.max_slot_ranges_per_request {
870                        return Err(GrpcError::InvalidArgument(format!(
871                            "too many slot ranges received. Only a maximum of {} slot ranges are accepted per request",
872                            grpc.grpc_config.max_slot_ranges_per_request
873                        )));
874                    }
875
876                    let start_slot: Option<Slot> = s_range.start_slot.map(|s| s.into());
877                    let end_slot: Option<Slot> = s_range.end_slot.map(|s| s.into());
878
879                    let slot_range = SlotRange {
880                        start_slot,
881                        end_slot,
882                    };
883                    slot_range.check()?;
884                    slot_ranges.insert(slot_range);
885                }
886            }
887        }
888    }
889
890    // filter by slot ranges
891    let selection_draws: HashSet<SlotDraw> = if let Some(slot_ranges) = slot_ranges_filter {
892        if slot_ranges.is_empty() {
893            return Err(GrpcError::InvalidArgument(
894                "at least, one slot range is required".to_string(),
895            ));
896        }
897
898        let mut start_slot = Slot::new(0, 0); // inclusive
899        let mut end_slot = Slot::new(u64::MAX, grpc.grpc_config.thread_count - 1); // exclusive
900        for slot_range in &slot_ranges {
901            start_slot = start_slot.max(slot_range.start_slot.unwrap_or_else(|| Slot::new(0, 0)));
902            end_slot = end_slot.min(
903                slot_range
904                    .end_slot
905                    .unwrap_or_else(|| Slot::new(u64::MAX, grpc.grpc_config.thread_count - 1)),
906            );
907        }
908        end_slot = end_slot.max(start_slot);
909
910        // get future draws from selector
911        let mut restrict_to_addresses: Option<&PreHashSet<Address>> = None;
912        if let Some(addresses) = &addresses_filter {
913            if !addresses.is_empty() {
914                restrict_to_addresses = Some(addresses);
915            }
916        }
917
918        grpc.selector_controller
919            .get_available_selections_in_range(start_slot..=end_slot, restrict_to_addresses)
920            .unwrap_or_default()
921            .into_iter()
922            .map(|(v_slot, v_sel)| {
923                let endorsement_producers: Vec<EndorsementDraw> = v_sel
924                    .endorsements
925                    .into_iter()
926                    .enumerate()
927                    .map(|(index, endo_sel)| EndorsementDraw {
928                        index: index as u64,
929                        producer: endo_sel.to_string(),
930                    })
931                    .collect();
932
933                SlotDraw {
934                    slot: Some(v_slot),
935                    block_producer: Some(v_sel.producer.to_string()),
936                    endorsement_draws: endorsement_producers,
937                }
938            })
939            .collect()
940    } else {
941        return Err(GrpcError::InvalidArgument(
942            "at least, one slot range is required".to_string(),
943        ));
944    };
945
946    Ok(grpc_api::GetSelectorDrawsResponse {
947        draws: selection_draws.into_iter().map(Into::into).collect(),
948    })
949}
950
951//  Get status
952pub(crate) fn get_status(
953    grpc: &MassaPublicGrpc,
954    _request: tonic::Request<grpc_api::GetStatusRequest>,
955) -> Result<grpc_api::GetStatusResponse, GrpcError> {
956    let config = CompactConfig::default();
957    let now = MassaTime::now();
958    let last_slot = get_latest_block_slot_at_timestamp(
959        grpc.grpc_config.thread_count,
960        grpc.grpc_config.t0,
961        grpc.grpc_config.genesis_timestamp,
962        now,
963    )?;
964
965    let current_cycle = last_slot
966        .unwrap_or_else(|| Slot::new(0, 0))
967        .get_cycle(grpc.grpc_config.periods_per_cycle);
968    let cycle_duration = grpc
969        .grpc_config
970        .t0
971        .checked_mul(grpc.grpc_config.periods_per_cycle)?;
972    let current_cycle_time = if current_cycle == 0 {
973        grpc.grpc_config.genesis_timestamp
974    } else {
975        cycle_duration
976            .checked_mul(current_cycle)
977            .and_then(|elapsed_time_before_current_cycle| {
978                grpc.grpc_config
979                    .genesis_timestamp
980                    .checked_add(elapsed_time_before_current_cycle)
981            })?
982    };
983    let next_cycle_time = current_cycle_time.checked_add(cycle_duration)?;
984    //TODO to be enhanced
985    let empty_request = ExecutionQueryRequest {
986        requests: vec![],
987        max_response_size: grpc.grpc_config.max_encoding_message_size,
988        max_event_count: None,
989        query_state_deadline_ms: None,
990    };
991    let state = grpc.execution_controller.query_state(empty_request);
992
993    let current_mip_version = grpc.keypair_factory.mip_store.get_network_version_current();
994
995    let status = grpc_model::PublicStatus {
996        node_id: grpc.node_id.to_string(),
997        version: grpc.version.to_string(),
998        current_time: Some(now.into()),
999        current_cycle,
1000        current_cycle_time: Some(current_cycle_time.into()),
1001        next_cycle_time: Some(next_cycle_time.into()),
1002        last_executed_final_slot: Some(state.final_cursor.into()),
1003        last_executed_speculative_slot: Some(state.candidate_cursor.into()),
1004        final_state_fingerprint: state.final_state_fingerprint.to_string(),
1005        config: Some(config.into()),
1006        chain_id: grpc.grpc_config.chain_id,
1007        minimal_fees: Some(grpc.grpc_config.minimal_fees.into()),
1008        current_mip_version,
1009        max_datastore_keys_query: grpc.grpc_config.max_datastore_keys_queries,
1010    };
1011
1012    Ok(grpc_api::GetStatusResponse {
1013        status: Some(status),
1014    })
1015}
1016
1017/// Get transactions throughput
1018pub(crate) fn get_transactions_throughput(
1019    grpc: &MassaPublicGrpc,
1020    _request: tonic::Request<grpc_api::GetTransactionsThroughputRequest>,
1021) -> Result<grpc_api::GetTransactionsThroughputResponse, GrpcError> {
1022    let stats = grpc.execution_controller.get_stats();
1023    let nb_sec_range = stats
1024        .time_window_end
1025        .saturating_sub(stats.time_window_start)
1026        .to_duration()
1027        .as_secs();
1028
1029    let throughput = stats
1030        .final_executed_operations_count
1031        .checked_div(nb_sec_range as usize)
1032        .unwrap_or_default() as u32;
1033
1034    Ok(grpc_api::GetTransactionsThroughputResponse { throughput })
1035}
1036
1037/// Get query state
1038pub(crate) fn query_state(
1039    grpc: &MassaPublicGrpc,
1040    request: tonic::Request<grpc_api::QueryStateRequest>,
1041) -> Result<grpc_api::QueryStateResponse, GrpcError> {
1042    let queries = request.into_inner().queries;
1043    if queries.is_empty() {
1044        return Err(GrpcError::InvalidArgument(
1045            "no query items specified".to_string(),
1046        ));
1047    }
1048    if queries.len() as u32 > grpc.grpc_config.max_query_items_per_request {
1049        return Err(GrpcError::InvalidArgument(format!("too many query items received. Only a maximum of {} operations are accepted per request", grpc.grpc_config.max_query_items_per_request)));
1050    }
1051
1052    let queries = queries
1053        .into_iter()
1054        .map(|q| {
1055            to_querystate_filter(
1056                q,
1057                grpc.grpc_config.max_datastore_keys_queries,
1058                grpc.grpc_config.max_datastore_key_length,
1059            )
1060        })
1061        .collect::<Result<Vec<_>, _>>()?;
1062
1063    let response = grpc
1064        .execution_controller
1065        .query_state(ExecutionQueryRequest {
1066            requests: queries,
1067            max_response_size: grpc.grpc_config.max_encoding_message_size,
1068            max_event_count: Some(grpc.grpc_config.max_event_per_query as usize),
1069            query_state_deadline_ms: grpc.grpc_config.query_state_deadline_ms,
1070        });
1071
1072    Ok(grpc_api::QueryStateResponse {
1073        final_cursor: Some(response.final_cursor.into()),
1074        candidate_cursor: Some(response.candidate_cursor.into()),
1075        final_state_fingerprint: response.final_state_fingerprint.to_string(),
1076        responses: response
1077            .responses
1078            .into_iter()
1079            .map(to_execution_query_response)
1080            .collect(),
1081    })
1082}
1083
1084/// Search blocks
1085pub(crate) fn search_blocks(
1086    grpc: &MassaPublicGrpc,
1087    request: tonic::Request<grpc_api::SearchBlocksRequest>,
1088) -> Result<grpc_api::SearchBlocksResponse, GrpcError> {
1089    let inner_req = request.into_inner();
1090    if inner_req.filters.len() as u32 > grpc.grpc_config.max_filters_per_request {
1091        return Err(GrpcError::InvalidArgument(format!(
1092            "too many filters received. Only a maximum of {} filters are accepted per request",
1093            grpc.grpc_config.max_filters_per_request
1094        )));
1095    }
1096
1097    let mut block_ids_filter: Option<PreHashSet<BlockId>> = None;
1098    let mut addresses_filter: Option<PreHashSet<Address>> = None;
1099    let mut slot_ranges_filter: Option<HashSet<SlotRange>> = None;
1100
1101    // Get params filter from the request.
1102    for query in inner_req.filters.into_iter() {
1103        if let Some(filter) = query.filter {
1104            match filter {
1105                grpc_api::search_blocks_filter::Filter::BlockIds(ids) => {
1106                    if ids.block_ids.len() as u32 > grpc.grpc_config.max_block_ids_per_request {
1107                        return Err(GrpcError::InvalidArgument(format!(
1108                            "too many block ids received. Only a maximum of {} block ids are accepted per request",
1109                            grpc.grpc_config.max_block_ids_per_request
1110                        )));
1111                    }
1112                    let block_ids = block_ids_filter.get_or_insert_with(PreHashSet::default);
1113                    for block_id in ids.block_ids {
1114                        block_ids.insert(BlockId::from_str(&block_id).map_err(|_| {
1115                            GrpcError::InvalidArgument(format!("invalid block id: {}", block_id))
1116                        })?);
1117                    }
1118                }
1119                grpc_api::search_blocks_filter::Filter::Addresses(addrs) => {
1120                    if addrs.addresses.len() as u32 > grpc.grpc_config.max_addresses_per_request {
1121                        return Err(GrpcError::InvalidArgument(format!(
1122                            "too many addresses received. Only a maximum of {} addresses are accepted per request",
1123                            grpc.grpc_config.max_addresses_per_request
1124                        )));
1125                    }
1126                    let addresses = addresses_filter.get_or_insert_with(PreHashSet::default);
1127                    for address in addrs.addresses {
1128                        addresses.insert(Address::from_str(&address).map_err(|_| {
1129                            GrpcError::InvalidArgument(format!("invalid address: {}", address))
1130                        })?);
1131                    }
1132                }
1133                grpc_api::search_blocks_filter::Filter::SlotRange(s_range) => {
1134                    let slot_ranges = slot_ranges_filter.get_or_insert_with(HashSet::new);
1135                    if slot_ranges.len() as u32 >= grpc.grpc_config.max_slot_ranges_per_request {
1136                        return Err(GrpcError::InvalidArgument(format!(
1137                            "too many slot ranges received. Only a maximum of {} slot ranges are accepted per request",
1138                            grpc.grpc_config.max_slot_ranges_per_request
1139                        )));
1140                    }
1141
1142                    let start_slot: Option<Slot> = s_range.start_slot.map(|s| s.into());
1143                    let end_slot: Option<Slot> = s_range.end_slot.map(|s| s.into());
1144
1145                    let slot_range = SlotRange {
1146                        start_slot,
1147                        end_slot,
1148                    };
1149                    slot_range.check()?;
1150                    slot_ranges.insert(slot_range);
1151                }
1152            }
1153        }
1154    }
1155
1156    // if no filter provided return an error
1157    if block_ids_filter.is_none() && addresses_filter.is_none() && slot_ranges_filter.is_none() {
1158        return Err(GrpcError::InvalidArgument("no filter provided".to_string()));
1159    }
1160
1161    let mut res: Option<PreHashSet<BlockId>> = None;
1162
1163    // filter by block ids
1164    if let Some(mut b_ids) = block_ids_filter {
1165        let read_lock = grpc.storage.read_blocks();
1166        b_ids.retain(|id: &BlockId| read_lock.contains(id));
1167
1168        res = Some(b_ids);
1169    }
1170
1171    // filter by addresses
1172    if let Some(addrs) = addresses_filter {
1173        let b_ids: PreHashSet<BlockId> = {
1174            let read_lock = grpc.storage.read_blocks();
1175            let mut b_ids: PreHashSet<BlockId> = PreHashSet::default();
1176            for addr in addrs {
1177                if let Some(addr_b_ids) = read_lock.get_blocks_created_by(&addr) {
1178                    b_ids.extend(addr_b_ids.clone());
1179                }
1180            }
1181
1182            b_ids
1183        };
1184        if let Some(block_ids) = res.as_mut() {
1185            block_ids.retain(|id: &BlockId| b_ids.contains(id));
1186        } else {
1187            res = Some(b_ids)
1188        }
1189    }
1190
1191    // filter by slot ranges
1192    if let Some(slot_ranges) = slot_ranges_filter {
1193        let mut start_slot = Slot::new(0, 0); // inclusive
1194        let mut end_slot = Slot::new(u64::MAX, grpc.grpc_config.thread_count - 1); // exclusive
1195        for slot_range in &slot_ranges {
1196            start_slot = start_slot.max(slot_range.start_slot.unwrap_or_else(|| Slot::new(0, 0)));
1197            end_slot = end_slot.min(
1198                slot_range
1199                    .end_slot
1200                    .unwrap_or_else(|| Slot::new(u64::MAX, grpc.grpc_config.thread_count - 1)),
1201            );
1202        }
1203        end_slot = end_slot.max(start_slot);
1204
1205        let read_lock = grpc.storage.read_blocks();
1206        let b_ids: PreHashSet<BlockId> =
1207            read_lock.aggregate_blocks_by_slot_range(start_slot..end_slot);
1208
1209        if let Some(block_ids) = res.as_mut() {
1210            block_ids.retain(|id: &BlockId| b_ids.contains(id));
1211        } else {
1212            res = Some(b_ids)
1213        }
1214    }
1215
1216    let block_ids: Vec<BlockId> = res.unwrap_or_default().into_iter().collect();
1217
1218    if block_ids.is_empty() {
1219        return Ok(grpc_api::SearchBlocksResponse {
1220            block_infos: vec![],
1221        });
1222    }
1223
1224    let blocks_status = grpc.consensus_controller.get_block_statuses(&block_ids);
1225
1226    let result = block_ids
1227        .iter()
1228        .zip(blocks_status)
1229        .map(|(block_id, block_graph_status)| grpc_model::BlockInfo {
1230            block_id: block_id.to_string(),
1231            status: block_graph_status.into(),
1232        })
1233        .collect();
1234
1235    Ok(grpc_api::SearchBlocksResponse {
1236        block_infos: result,
1237    })
1238}
1239
1240/// Search endorsements
1241pub(crate) fn search_endorsements(
1242    grpc: &MassaPublicGrpc,
1243    request: tonic::Request<grpc_api::SearchEndorsementsRequest>,
1244) -> Result<grpc_api::SearchEndorsementsResponse, GrpcError> {
1245    let inner_req = request.into_inner();
1246    if inner_req.filters.len() as u32 > grpc.grpc_config.max_filters_per_request {
1247        return Err(GrpcError::InvalidArgument(format!(
1248            "too many filters received. Only a maximum of {} filters are accepted per request",
1249            grpc.grpc_config.max_filters_per_request
1250        )));
1251    }
1252
1253    let mut endorsement_ids_filter: Option<PreHashSet<EndorsementId>> = None;
1254    let mut addresses_filter: Option<PreHashSet<Address>> = None;
1255    let mut block_ids_filter: Option<PreHashSet<BlockId>> = None;
1256
1257    // Get params filter from the request.
1258    for query in inner_req.filters.into_iter() {
1259        if let Some(filter) = query.filter {
1260            match filter {
1261                grpc_api::search_endorsements_filter::Filter::EndorsementIds(ids) => {
1262                    if ids.endorsement_ids.len() as u32
1263                        > grpc.grpc_config.max_endorsement_ids_per_request
1264                    {
1265                        return Err(GrpcError::InvalidArgument(format!(
1266                            "too many endorsement ids received. Only a maximum of {} endorsement ids are accepted per request",
1267                            grpc.grpc_config.max_endorsement_ids_per_request
1268                        )));
1269                    }
1270                    let endorsement_ids =
1271                        endorsement_ids_filter.get_or_insert_with(PreHashSet::default);
1272                    for id in ids.endorsement_ids {
1273                        endorsement_ids.insert(EndorsementId::from_str(&id).map_err(|_| {
1274                            GrpcError::InvalidArgument(format!("invalid endorsement id: {}", id))
1275                        })?);
1276                    }
1277                }
1278                grpc_api::search_endorsements_filter::Filter::Addresses(addrs) => {
1279                    if addrs.addresses.len() as u32 > grpc.grpc_config.max_addresses_per_request {
1280                        return Err(GrpcError::InvalidArgument(format!(
1281                            "too many addresses received. Only a maximum of {} addresses are accepted per request",
1282                            grpc.grpc_config.max_addresses_per_request
1283                        )));
1284                    }
1285                    let addresses = addresses_filter.get_or_insert_with(PreHashSet::default);
1286                    for address in addrs.addresses {
1287                        addresses.insert(Address::from_str(&address).map_err(|_| {
1288                            GrpcError::InvalidArgument(format!("invalid address: {}", address))
1289                        })?);
1290                    }
1291                }
1292                grpc_api::search_endorsements_filter::Filter::BlockIds(ids) => {
1293                    if ids.block_ids.len() as u32 > grpc.grpc_config.max_block_ids_per_request {
1294                        return Err(GrpcError::InvalidArgument(format!(
1295                            "too many block ids received. Only a maximum of {} block ids are accepted per request",
1296                            grpc.grpc_config.max_block_ids_per_request
1297                        )));
1298                    }
1299                    let block_ids = block_ids_filter.get_or_insert_with(PreHashSet::default);
1300                    for block_id in ids.block_ids {
1301                        block_ids.insert(BlockId::from_str(&block_id).map_err(|_| {
1302                            GrpcError::InvalidArgument(format!("invalid block id: {}", block_id))
1303                        })?);
1304                    }
1305                }
1306            }
1307        }
1308    }
1309
1310    // if no filter provided return an error
1311    if endorsement_ids_filter.is_none() && addresses_filter.is_none() && block_ids_filter.is_none()
1312    {
1313        return Err(GrpcError::InvalidArgument("no filter provided".to_string()));
1314    }
1315
1316    let mut eds_ids: Option<PreHashSet<EndorsementId>> = None;
1317
1318    // filter by endorsement ids
1319    if let Some(mut e_ids) = endorsement_ids_filter {
1320        let read_lock = grpc.storage.read_endorsements();
1321        e_ids.retain(|id: &EndorsementId| read_lock.contains(id));
1322        eds_ids = Some(e_ids);
1323    }
1324
1325    // filter by addresses
1326    if let Some(addrs) = addresses_filter {
1327        let e_ids: PreHashSet<EndorsementId> = {
1328            let mut e_ids: PreHashSet<EndorsementId> = PreHashSet::default();
1329            let read_lock = grpc.storage.read_endorsements();
1330            for addr in addrs {
1331                if let Some(addr_e_ids) = read_lock.get_endorsements_created_by(&addr) {
1332                    e_ids.extend(addr_e_ids.clone());
1333                }
1334            }
1335
1336            e_ids
1337        };
1338        if let Some(endorsement_ids) = eds_ids.as_mut() {
1339            endorsement_ids.retain(|id: &EndorsementId| e_ids.contains(id));
1340        } else {
1341            eds_ids = Some(e_ids)
1342        }
1343    }
1344
1345    // filter by block ids
1346    if let Some(b_ids) = block_ids_filter {
1347        let mut e_ids: PreHashSet<EndorsementId> = PreHashSet::default();
1348        let read_lock = grpc.storage.read_blocks();
1349        for block_id in b_ids {
1350            if let Some(wrapped_block) = read_lock.get(&block_id) {
1351                let b_endorsements: PreHashSet<EndorsementId> = wrapped_block
1352                    .content
1353                    .header
1354                    .content
1355                    .endorsements
1356                    .iter()
1357                    .map(|wrapped_endorsement| wrapped_endorsement.id)
1358                    .collect();
1359                e_ids.extend(&b_endorsements);
1360            }
1361        }
1362
1363        if let Some(endorsement_ids) = eds_ids.as_mut() {
1364            endorsement_ids.retain(|id: &EndorsementId| e_ids.contains(id));
1365        } else {
1366            eds_ids = Some(e_ids)
1367        }
1368    }
1369
1370    let storage_info: Vec<(EndorsementId, PreHashSet<BlockId>)> = {
1371        let read_blocks_lock = grpc.storage.read_blocks();
1372        if let Some(endorsement_ids) = eds_ids {
1373            endorsement_ids
1374                .into_iter()
1375                .map(|id| {
1376                    let block_ids = read_blocks_lock
1377                        .get_blocks_by_endorsement(&id)
1378                        .cloned()
1379                        .unwrap_or_default();
1380
1381                    (id, block_ids)
1382                })
1383                .collect()
1384        } else {
1385            return Ok(grpc_api::SearchEndorsementsResponse {
1386                endorsement_infos: Vec::new(),
1387            });
1388        }
1389    };
1390
1391    // keep only the endorsements found in storage
1392    let e_ids: Vec<EndorsementId> = storage_info.iter().map(|(ed, _)| *ed).collect();
1393
1394    // ask pool whether it carries the endorsements
1395    let in_pool = grpc
1396        .pool_controller
1397        .contains_endorsements(
1398            &e_ids,
1399            Some(MassaTime::from_millis(
1400                grpc.grpc_config.timeout.as_millis() as u64
1401            )),
1402        )
1403        .unwrap_or_else(|_| vec![false; e_ids.len()]);
1404
1405    // check finality by cross-referencing Consensus and looking for final blocks that contain the endorsement
1406    let is_final: Vec<bool> = {
1407        let involved_blocks: Vec<BlockId> = storage_info
1408            .iter()
1409            .flat_map(|(_ed, bs)| bs.iter())
1410            .unique()
1411            .cloned()
1412            .collect();
1413
1414        let involved_block_statuses = grpc
1415            .consensus_controller
1416            .get_block_statuses(&involved_blocks);
1417
1418        let block_statuses: PreHashMap<BlockId, BlockGraphStatus> = involved_blocks
1419            .into_iter()
1420            .zip(involved_block_statuses)
1421            .collect();
1422        storage_info
1423            .iter()
1424            .map(|(_ed, bs)| {
1425                bs.iter()
1426                    .any(|b| block_statuses.get(b) == Some(&BlockGraphStatus::Final))
1427            })
1428            .collect()
1429    };
1430
1431    // gather all values into a vector of EndorsementInfo instances
1432    let mut res: Vec<grpc_model::EndorsementInfo> = Vec::with_capacity(e_ids.len());
1433    let zipped_iterator = izip!(
1434        storage_info.into_iter(),
1435        in_pool.into_iter(),
1436        is_final.into_iter()
1437    );
1438
1439    for ((e_id, in_blocks), in_pool, is_final) in zipped_iterator {
1440        res.push(grpc_model::EndorsementInfo {
1441            in_pool,
1442            is_final,
1443            in_blocks: in_blocks
1444                .into_iter()
1445                .map(|block_id| block_id.to_string())
1446                .collect(),
1447            endorsement_id: e_id.to_string(),
1448        });
1449    }
1450
1451    Ok(grpc_api::SearchEndorsementsResponse {
1452        endorsement_infos: res,
1453    })
1454}
1455
1456/// Search operations
1457pub(crate) fn search_operations(
1458    grpc: &MassaPublicGrpc,
1459    request: tonic::Request<grpc_api::SearchOperationsRequest>,
1460) -> Result<grpc_api::SearchOperationsResponse, GrpcError> {
1461    let inner_req: grpc_api::SearchOperationsRequest = request.into_inner();
1462    if inner_req.filters.len() as u32 > grpc.grpc_config.max_filters_per_request {
1463        return Err(GrpcError::InvalidArgument(format!(
1464            "too many filters received. Only a maximum of {} filters are accepted per request",
1465            grpc.grpc_config.max_filters_per_request
1466        )));
1467    }
1468    let mut operation_ids_filter: Option<PreHashSet<OperationId>> = None;
1469    let mut addresses_filter: Option<PreHashSet<Address>> = None;
1470
1471    // Get params filter from the request.
1472    for query in inner_req.filters.into_iter() {
1473        if let Some(filter) = query.filter {
1474            match filter {
1475                grpc_api::search_operations_filter::Filter::OperationIds(ids) => {
1476                    if ids.operation_ids.len() as u32
1477                        > grpc.grpc_config.max_operation_ids_per_request
1478                    {
1479                        return Err(GrpcError::InvalidArgument(format!(
1480                            "too many operation ids received. Only a maximum of {} operation ids are accepted per request",
1481                            grpc.grpc_config.max_operation_ids_per_request
1482                        )));
1483                    }
1484                    let operation_ids =
1485                        operation_ids_filter.get_or_insert_with(PreHashSet::default);
1486                    for id in ids.operation_ids {
1487                        operation_ids.insert(OperationId::from_str(&id).map_err(|_| {
1488                            GrpcError::InvalidArgument(format!("invalid operation id: {}", id))
1489                        })?);
1490                    }
1491                }
1492                grpc_api::search_operations_filter::Filter::Addresses(addrs) => {
1493                    if addrs.addresses.len() as u32 > grpc.grpc_config.max_addresses_per_request {
1494                        return Err(GrpcError::InvalidArgument(format!(
1495                            "too many addresses received. Only a maximum of {} addresses are accepted per request",
1496                            grpc.grpc_config.max_addresses_per_request
1497                        )));
1498                    }
1499                    let addresses = addresses_filter.get_or_insert_with(PreHashSet::default);
1500                    for address in addrs.addresses {
1501                        addresses.insert(Address::from_str(&address).map_err(|_| {
1502                            GrpcError::InvalidArgument(format!("invalid address: {}", address))
1503                        })?);
1504                    }
1505                }
1506            }
1507        }
1508    }
1509
1510    if operation_ids_filter.is_none() && addresses_filter.is_none() {
1511        return Err(GrpcError::InvalidArgument("no filter provided".to_string()));
1512    }
1513
1514    let mut ops_ids: Option<PreHashSet<OperationId>> = None;
1515
1516    // filter by operation ids
1517    if let Some(mut o_ids) = operation_ids_filter {
1518        let read_lock = grpc.storage.read_operations();
1519        o_ids.retain(|id: &OperationId| read_lock.contains(id));
1520        ops_ids = Some(o_ids);
1521    }
1522
1523    // filter by addresses
1524    if let Some(addrs) = addresses_filter {
1525        let o_ids: PreHashSet<OperationId> = {
1526            let read_lock = grpc.storage.read_operations();
1527            let mut o_ids: PreHashSet<OperationId> = PreHashSet::default();
1528            for addr in addrs {
1529                if let Some(addr_o_ids) = read_lock.get_operations_created_by(&addr) {
1530                    o_ids.extend(addr_o_ids.clone());
1531                }
1532            }
1533
1534            o_ids
1535        };
1536        if let Some(operation_ids) = ops_ids.as_mut() {
1537            operation_ids.retain(|id: &OperationId| o_ids.contains(id));
1538        } else {
1539            ops_ids = Some(o_ids)
1540        }
1541    }
1542
1543    let operations: Vec<grpc_model::OperationInfo> = if let Some(operation_ids) = ops_ids {
1544        let secure_share_operations: Vec<SecureShareOperation> = {
1545            let read_ops = grpc.storage.read_operations();
1546            operation_ids
1547                .iter()
1548                .filter_map(|id| read_ops.get(id).cloned())
1549                .collect()
1550        };
1551
1552        let storage_info: Vec<(SecureShareOperation, PreHashSet<BlockId>)> = {
1553            let read_blocks = grpc.storage.read_blocks();
1554            secure_share_operations
1555                .into_iter()
1556                .map(|secure_share_operation| {
1557                    let op_id = secure_share_operation.id;
1558                    (
1559                        secure_share_operation,
1560                        read_blocks
1561                            .get_blocks_by_operation(&op_id)
1562                            .cloned()
1563                            .unwrap_or_default(),
1564                    )
1565                })
1566                .collect()
1567        };
1568
1569        storage_info
1570            .into_iter()
1571            .map(|secureshare| {
1572                let (secureshare_operation, block_ids) = secureshare;
1573                grpc_model::OperationInfo {
1574                    id: secureshare_operation.id.to_string(),
1575                    thread: secureshare_operation
1576                        .content_creator_address
1577                        .get_thread(grpc.grpc_config.thread_count)
1578                        as u32,
1579                    block_ids: block_ids.into_iter().map(|id| id.to_string()).collect(),
1580                }
1581            })
1582            .collect()
1583    } else {
1584        Vec::new()
1585    };
1586
1587    Ok(grpc_api::SearchOperationsResponse {
1588        operation_infos: operations,
1589    })
1590}