1use 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
46pub(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, });
115 call_stack.push(ExecutionStackElement {
118 address: target_address,
119 coins: coins.unwrap_or_default(),
120 owned_addresses: vec![target_address],
121 operation_datastore: None, });
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 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 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
183pub(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
239pub(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 if inner_req.filters.is_empty() {
248 return Err(GrpcError::InvalidArgument("no filter provided".to_string()));
249 }
250
251 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
292pub(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 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 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 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
413pub(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 let mut filter_opt = (None, None, None);
422
423 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 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 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 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")]
503pub 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")]
540pub(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 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 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")]
628pub(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
718pub(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
735pub(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
804pub(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 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
834pub(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 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 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); let mut end_slot = Slot::new(u64::MAX, grpc.grpc_config.thread_count - 1); 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 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
951pub(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 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
1017pub(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
1037pub(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
1084pub(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 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 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 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 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 if let Some(slot_ranges) = slot_ranges_filter {
1193 let mut start_slot = Slot::new(0, 0); let mut end_slot = Slot::new(u64::MAX, grpc.grpc_config.thread_count - 1); 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
1240pub(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 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 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 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 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 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 let e_ids: Vec<EndorsementId> = storage_info.iter().map(|(ed, _)| *ed).collect();
1393
1394 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 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 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
1456pub(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 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 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 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}