1use call::{DeferredCallDeserializer, DeferredCallSerializer};
2use config::DeferredCallsConfig;
3use macros::{
4 CALL_FIELD_CANCELED, CALL_FIELD_COINS, CALL_FIELD_FEE, CALL_FIELD_MAX_GAS,
5 CALL_FIELD_PARAMETERS, CALL_FIELD_SENDER_ADDRESS, CALL_FIELD_TARGET_ADDRESS,
6 CALL_FIELD_TARGET_FUNCTION, CALL_FIELD_TARGET_SLOT,
7};
8use massa_db_exports::{
9 DBBatch, ShareableMassaDBController, CRUD_ERROR, DEFERRED_CALLS_PREFIX,
10 DEFERRED_CALL_DESER_ERROR, DEFERRED_CALL_SER_ERROR, DEFERRED_CALL_TOTAL_GAS, KEY_DESER_ERROR,
11 STATE_CF,
12};
13use massa_models::{address::Address, slot::SlotDeserializer};
14use massa_serialization::{
15 buf_to_array_ctr, DeserializeError, Deserializer, Serializer, U128VarIntDeserializer,
16 U128VarIntSerializer,
17};
18use registry_changes::DeferredCallRegistryChanges;
19
20mod call;
23pub mod config;
24pub mod registry_changes;
25pub mod slot_changes;
26
27#[cfg(test)]
28mod tests;
29
30#[macro_use]
31mod macros;
32
33pub use call::DeferredCall;
34use massa_models::types::{SetOrDelete, SetOrKeep, SetOrKeepDeserializer, SetOrKeepSerializer};
35use massa_models::{
36 amount::Amount,
37 deferred_calls::{DeferredCallId, DeferredCallIdDeserializer, DeferredCallIdSerializer},
38 slot::Slot,
39};
40use std::collections::{BTreeMap, HashSet};
41use std::ops::Bound;
42
43pub struct DeferredCallRegistry {
45 db: ShareableMassaDBController,
46 call_serializer: DeferredCallSerializer,
47 call_id_serializer: DeferredCallIdSerializer,
48 call_deserializer: DeferredCallDeserializer,
49 call_id_deserializer: DeferredCallIdDeserializer,
50 slot_deserializer: SlotDeserializer,
51 effective_total_gas_deserializer: SetOrKeepDeserializer<u128, U128VarIntDeserializer>,
52 effective_total_gas_serializer: SetOrKeepSerializer<u128, U128VarIntSerializer>,
53}
54
55impl DeferredCallRegistry {
56 pub fn new(db: ShareableMassaDBController, config: DeferredCallsConfig) -> Self {
65 Self {
66 db,
67 call_serializer: DeferredCallSerializer::new(),
68 call_id_serializer: DeferredCallIdSerializer::new(),
69 call_deserializer: DeferredCallDeserializer::new(config),
70 call_id_deserializer: DeferredCallIdDeserializer::new(),
71 slot_deserializer: SlotDeserializer::new(
72 (Bound::Included(0), Bound::Included(u64::MAX)),
73 (Bound::Included(0), Bound::Excluded(config.thread_count)),
74 ),
75 effective_total_gas_deserializer: SetOrKeepDeserializer::new(
76 U128VarIntDeserializer::new(Bound::Included(u128::MIN), Bound::Included(u128::MAX)),
77 ),
78 effective_total_gas_serializer: SetOrKeepSerializer::new(U128VarIntSerializer::new()),
79 }
80 }
81
82 pub fn get_slot_calls(&self, slot: Slot) -> DeferredSlotCalls {
84 let mut to_return = DeferredSlotCalls::new(slot);
85 let key = deferred_slot_call_prefix_key!(slot.to_bytes_key());
86
87 let mut temp = HashSet::new();
88
89 for (serialized_key, _serialized_value) in self.db.read().prefix_iterator_cf(STATE_CF, &key)
90 {
91 if !serialized_key.starts_with(&key) {
92 break;
93 }
94
95 let rest_key = &serialized_key[key.len()..];
96
97 let (_rest, call_id) = self
98 .call_id_deserializer
99 .deserialize::<DeserializeError>(rest_key)
100 .expect(KEY_DESER_ERROR);
101
102 if !temp.insert(call_id.clone()) {
103 continue;
104 }
105
106 if let Some(call) = self.get_call(&slot, &call_id) {
107 to_return.slot_calls.insert(call_id, call);
108 }
109 }
110
111 to_return.slot_base_fee = self.get_slot_base_fee(&slot);
112 to_return.effective_slot_gas = self.get_slot_gas(&slot);
113
114 to_return
115 }
116
117 pub fn get_call(&self, slot: &Slot, id: &DeferredCallId) -> Option<DeferredCall> {
119 let mut buf_id = Vec::new();
120 self.call_id_serializer
121 .serialize(id, &mut buf_id)
122 .expect(DEFERRED_CALL_SER_ERROR);
123 let key = deferred_call_prefix_key!(buf_id, slot.to_bytes_key());
124
125 let mut serialized_call: Vec<u8> = Vec::new();
126 for (serialized_key, serialized_value) in self.db.read().prefix_iterator_cf(STATE_CF, &key)
127 {
128 if !serialized_key.starts_with(&key) {
129 break;
130 }
131
132 serialized_call.extend(serialized_value.iter());
133 }
134
135 match self
136 .call_deserializer
137 .deserialize::<DeserializeError>(&serialized_call)
138 {
139 Ok((_rest, call)) => Some(call),
140 Err(_) => None,
141 }
142 }
143
144 pub fn get_slot_gas(&self, slot: &Slot) -> u64 {
146 let key = deferred_call_slot_total_gas_key!(slot.to_bytes_key());
148 match self.db.read().get_cf(STATE_CF, key) {
149 Ok(Some(v)) => {
150 let result = self
151 .call_deserializer
152 .u64_var_int_deserializer
153 .deserialize::<DeserializeError>(&v)
154 .expect(DEFERRED_CALL_DESER_ERROR)
155 .1;
156 result
157 }
158 _ => 0,
159 }
160 }
161
162 pub fn get_slot_base_fee(&self, slot: &Slot) -> Amount {
166 let key = deferred_call_slot_base_fee_key!(slot.to_bytes_key());
167 match self.db.read().get_cf(STATE_CF, key) {
168 Ok(Some(v)) => {
169 self.call_deserializer
170 .amount_deserializer
171 .deserialize::<DeserializeError>(&v)
172 .expect(DEFERRED_CALL_DESER_ERROR)
173 .1
174 }
175 _ => Amount::zero(),
176 }
177 }
178
179 pub fn get_total_gas(&self) -> u128 {
181 match self
182 .db
183 .read()
184 .get_cf(STATE_CF, DEFERRED_CALL_TOTAL_GAS.as_bytes().to_vec())
185 .expect(CRUD_ERROR)
186 {
187 Some(v) => {
188 let result = self
189 .effective_total_gas_deserializer
190 .deserialize::<DeserializeError>(&v)
191 .expect(DEFERRED_CALL_DESER_ERROR)
192 .1;
193
194 match result {
195 DeferredRegistryGasChange::Set(v) => v,
196 DeferredRegistryGasChange::Keep => 0,
197 }
198 }
199 None => 0,
200 }
201 }
202
203 pub fn put_entry(
204 &self,
205 slot: &Slot,
206 call_id: &DeferredCallId,
207 call: &DeferredCall,
208 batch: &mut DBBatch,
209 ) {
210 let mut buffer_id = Vec::new();
211 self.call_id_serializer
212 .serialize(call_id, &mut buffer_id)
213 .expect(DEFERRED_CALL_SER_ERROR);
214
215 let slot_bytes = slot.to_bytes_key();
216
217 let db = self.db.read();
218
219 {
220 let mut buffer = Vec::new();
222 self.call_serializer
223 .address_serializer
224 .serialize(&call.sender_address, &mut buffer)
225 .expect(DEFERRED_CALL_SER_ERROR);
226 db.put_or_update_entry_value(
227 batch,
228 sender_address_key!(buffer_id, slot_bytes),
229 &buffer,
230 );
231 }
232
233 {
234 let mut buffer = Vec::new();
236 self.call_serializer
237 .slot_serializer
238 .serialize(&call.target_slot, &mut buffer)
239 .expect(DEFERRED_CALL_SER_ERROR);
240 db.put_or_update_entry_value(batch, target_slot_key!(buffer_id, slot_bytes), &buffer);
241 }
242
243 {
244 let mut buffer = Vec::new();
246 self.call_serializer
247 .address_serializer
248 .serialize(&call.target_address, &mut buffer)
249 .expect(DEFERRED_CALL_SER_ERROR);
250 db.put_or_update_entry_value(
251 batch,
252 target_address_key!(buffer_id, slot_bytes),
253 &buffer,
254 );
255 }
256
257 {
258 let mut buffer = Vec::new();
260 self.call_serializer
261 .string_serializer
262 .serialize(&call.target_function, &mut buffer)
263 .expect(DEFERRED_CALL_SER_ERROR);
264 db.put_or_update_entry_value(
265 batch,
266 target_function_key!(buffer_id, slot_bytes),
267 &buffer,
268 );
269 }
270
271 {
272 let mut buffer = Vec::new();
274 self.call_serializer
275 .vec_u8_serializer
276 .serialize(&call.parameters, &mut buffer)
277 .expect(DEFERRED_CALL_SER_ERROR);
278 db.put_or_update_entry_value(batch, parameters_key!(buffer_id, slot_bytes), &buffer);
279 }
280
281 {
282 let mut buffer = Vec::new();
284 self.call_serializer
285 .amount_serializer
286 .serialize(&call.coins, &mut buffer)
287 .expect(DEFERRED_CALL_SER_ERROR);
288 db.put_or_update_entry_value(batch, coins_key!(buffer_id, slot_bytes), &buffer);
289 }
290
291 {
292 let mut buffer = Vec::new();
294 self.call_serializer
295 .u64_var_int_serializer
296 .serialize(&call.max_gas, &mut buffer)
297 .expect(DEFERRED_CALL_SER_ERROR);
298 db.put_or_update_entry_value(batch, max_gas_key!(buffer_id, slot_bytes), &buffer);
299 }
300
301 {
302 let mut buffer = Vec::new();
304 self.call_serializer
305 .amount_serializer
306 .serialize(&call.fee, &mut buffer)
307 .expect(DEFERRED_CALL_SER_ERROR);
308 db.put_or_update_entry_value(batch, fee_key!(buffer_id, slot_bytes), &buffer);
309 }
310
311 let mut buffer = Vec::new();
313 self.call_serializer
314 .bool_serializer
315 .serialize(&call.cancelled, &mut buffer)
316 .expect(DEFERRED_CALL_SER_ERROR);
317 db.put_or_update_entry_value(batch, cancelled_key!(buffer_id, slot_bytes), &buffer);
318 }
319
320 fn delete_entry(&self, id: &DeferredCallId, slot: &Slot, batch: &mut DBBatch) {
321 let mut buffer_id = Vec::new();
322 self.call_id_serializer
323 .serialize(id, &mut buffer_id)
324 .expect(DEFERRED_CALL_SER_ERROR);
325
326 let slot_bytes = slot.to_bytes_key();
327
328 let db = self.db.read();
329
330 db.delete_key(batch, sender_address_key!(buffer_id, slot_bytes));
331 db.delete_key(batch, target_slot_key!(buffer_id, slot_bytes));
332 db.delete_key(batch, target_address_key!(buffer_id, slot_bytes));
333 db.delete_key(batch, target_function_key!(buffer_id, slot_bytes));
334 db.delete_key(batch, parameters_key!(buffer_id, slot_bytes));
335 db.delete_key(batch, coins_key!(buffer_id, slot_bytes));
336 db.delete_key(batch, max_gas_key!(buffer_id, slot_bytes));
337 db.delete_key(batch, fee_key!(buffer_id, slot_bytes));
338 db.delete_key(batch, cancelled_key!(buffer_id, slot_bytes));
339 }
340
341 pub fn apply_changes_to_batch(
342 &self,
343 changes: DeferredCallRegistryChanges,
344 batch: &mut DBBatch,
345 ) {
346 for change in changes.slots_change.iter() {
350 let slot = change.0;
351 let slot_changes = change.1;
352 for (id, call_change) in slot_changes.calls.iter() {
353 match call_change {
354 DeferredRegistryCallChange::Set(call) => {
355 if call.cancelled {
356 massa_metrics::inc_deferred_calls_cancelled();
357 } else {
358 massa_metrics::inc_deferred_calls_registered();
359 }
360 self.put_entry(slot, id, call, batch);
361 }
362 DeferredRegistryCallChange::Delete => {
363 self.delete_entry(id, slot, batch);
364 }
365 }
366 }
367 match slot_changes.effective_slot_gas {
368 DeferredRegistryGasChange::Set(v) => {
369 let key = deferred_call_slot_total_gas_key!(slot.to_bytes_key());
370 if v.eq(&0) {
372 self.db.read().delete_key(batch, key);
373 } else {
374 let mut value_ser = Vec::new();
375 self.call_serializer
376 .u64_var_int_serializer
377 .serialize(&v, &mut value_ser)
378 .expect(DEFERRED_CALL_SER_ERROR);
379 self.db
380 .read()
381 .put_or_update_entry_value(batch, key, &value_ser);
382 }
383 }
384 DeferredRegistryGasChange::Keep => {}
385 }
386 match slot_changes.base_fee {
387 DeferredRegistryBaseFeeChange::Set(v) => {
388 let key = deferred_call_slot_base_fee_key!(slot.to_bytes_key());
389 if v.eq(&Amount::zero()) {
391 self.db.read().delete_key(batch, key);
392 } else {
393 let mut value_ser = Vec::new();
394 self.call_serializer
395 .amount_serializer
396 .serialize(&v, &mut value_ser)
397 .expect(DEFERRED_CALL_SER_ERROR);
398 self.db
399 .read()
400 .put_or_update_entry_value(batch, key, &value_ser);
401 }
402 }
403 DeferredRegistryBaseFeeChange::Keep => {}
404 }
405 }
406
407 match changes.effective_total_gas {
408 DeferredRegistryGasChange::Set(val) => {
409 massa_metrics::set_deferred_calls_total_gas(val);
410 let key = DEFERRED_CALL_TOTAL_GAS.as_bytes().to_vec();
411 let mut value_ser = Vec::new();
412 self.effective_total_gas_serializer
413 .serialize(&changes.effective_total_gas, &mut value_ser)
414 .expect(DEFERRED_CALL_SER_ERROR);
415 self.db
416 .read()
417 .put_or_update_entry_value(batch, key, &value_ser);
418 }
419 DeferredRegistryGasChange::Keep => {}
420 }
421
422 if changes.exec_stats.0 > 0 {
423 massa_metrics::inc_deferred_calls_executed_by(changes.exec_stats.0);
425 }
426 if changes.exec_stats.1 > 0 {
427 massa_metrics::inc_deferred_calls_failed_by(changes.exec_stats.1);
429 }
430 if changes.exec_stats.2 > 0 {
431 massa_metrics::dec_deferred_calls_cancelled_by(changes.exec_stats.2);
433 }
434 let total_no_more_registered = changes
435 .exec_stats
436 .0
437 .saturating_add(changes.exec_stats.1)
438 .saturating_add(changes.exec_stats.2);
439 if total_no_more_registered > 0 {
440 massa_metrics::dec_deferred_calls_registered_by(total_no_more_registered);
442 }
443 }
444
445 pub fn is_key_value_valid(&self, serialized_key: &[u8], serialized_value: &[u8]) -> bool {
446 if serialized_key.starts_with(DEFERRED_CALLS_PREFIX.as_bytes()) {
447 if let Some((_rest, slot)) = buf_to_array_ctr(
449 &serialized_key[DEFERRED_CALLS_PREFIX.len()..],
450 Slot::from_bytes_key,
451 ) {
452 if serialized_key
454 .starts_with(&deferred_call_slot_total_gas_key!(&slot.to_bytes_key()))
455 {
456 return self
457 .call_deserializer
458 .u64_var_int_deserializer
459 .deserialize::<DeserializeError>(serialized_value)
460 .is_ok();
461 } else if serialized_key
462 .starts_with(&deferred_call_slot_base_fee_key!(&slot.to_bytes_key()))
463 {
464 return self
466 .call_deserializer
467 .amount_deserializer
468 .deserialize::<DeserializeError>(serialized_value)
469 .is_ok();
470 } else {
471 let k = deferred_slot_call_prefix_key!(&slot.to_bytes_key());
475 if !serialized_key.starts_with(&k) {
477 return false;
478 }
479 let rest_key = &serialized_key[k.len()..];
480
481 if let Ok((rest, _id)) = self
482 .call_id_deserializer
483 .deserialize::<DeserializeError>(rest_key)
484 {
485 if rest.len() != 1 {
487 return false;
488 }
489 match rest[0] {
490 CALL_FIELD_SENDER_ADDRESS => {
491 let res: Result<(&[u8], Address), nom::Err<DeserializeError<'_>>> =
492 self.call_deserializer
493 .address_deserializer
494 .deserialize::<DeserializeError>(serialized_value);
495
496 return res.is_ok();
497 }
498 CALL_FIELD_TARGET_SLOT => {
499 return self
500 .slot_deserializer
501 .deserialize::<DeserializeError>(serialized_value)
502 .is_ok()
503 }
504 CALL_FIELD_TARGET_ADDRESS => {
505 let res: Result<(&[u8], Address), nom::Err<DeserializeError<'_>>> =
506 self.call_deserializer
507 .address_deserializer
508 .deserialize::<DeserializeError>(serialized_value);
509 return res.is_ok();
510 }
511 CALL_FIELD_TARGET_FUNCTION => {
512 return self
513 .call_deserializer
514 .string_deserializer
515 .deserialize::<DeserializeError>(serialized_value)
516 .is_ok()
517 }
518 CALL_FIELD_PARAMETERS => {
519 return self
520 .call_deserializer
521 .vec_u8_deserializer
522 .deserialize::<DeserializeError>(serialized_value)
523 .is_ok()
524 }
525 CALL_FIELD_MAX_GAS => {
526 return self
527 .call_deserializer
528 .u64_var_int_deserializer
529 .deserialize::<DeserializeError>(serialized_value)
530 .is_ok()
531 }
532 CALL_FIELD_FEE => {
533 return self
534 .call_deserializer
535 .amount_deserializer
536 .deserialize::<DeserializeError>(serialized_value)
537 .is_ok()
538 }
539 CALL_FIELD_CANCELED => {
540 return self
541 .call_deserializer
542 .bool_deserializer
543 .deserialize::<DeserializeError>(serialized_value)
544 .is_ok();
545 }
546 CALL_FIELD_COINS => {
547 return self
548 .call_deserializer
549 .amount_deserializer
550 .deserialize::<DeserializeError>(serialized_value)
551 .is_ok();
552 }
553 _ => {}
554 }
555 }
556 }
557 }
558 } else if serialized_key.eq(DEFERRED_CALL_TOTAL_GAS.as_bytes()) {
559 return self
560 .effective_total_gas_deserializer
561 .deserialize::<DeserializeError>(serialized_value)
562 .is_ok();
563 }
564 false
565 }
566}
567
568pub type DeferredRegistryCallChange = SetOrDelete<DeferredCall>;
569pub type DeferredRegistryGasChange<V> = SetOrKeep<V>;
570pub type DeferredRegistryBaseFeeChange = SetOrKeep<Amount>;
571
572#[derive(Debug, Clone)]
578pub struct DeferredSlotCalls {
579 pub slot: Slot,
580 pub slot_calls: BTreeMap<DeferredCallId, DeferredCall>,
581
582 pub effective_slot_gas: u64,
585
586 pub slot_base_fee: Amount,
587}
588
589impl DeferredSlotCalls {
590 pub fn new(slot: Slot) -> Self {
591 Self {
592 slot,
593 slot_calls: BTreeMap::new(),
594 effective_slot_gas: 0,
595 slot_base_fee: Amount::zero(),
596 }
597 }
598
599 pub fn apply_changes(&mut self, changes: &DeferredCallRegistryChanges) {
605 let Some(slot_changes) = changes.slots_change.get(&self.slot) else {
606 return;
607 };
608 for (id, change) in &slot_changes.calls {
609 match change {
610 DeferredRegistryCallChange::Set(call) => {
611 self.slot_calls.insert(id.clone(), call.clone());
612 }
613 DeferredRegistryCallChange::Delete => {
614 self.slot_calls.remove(id);
615 }
616 }
617 }
618 match slot_changes.effective_slot_gas {
619 DeferredRegistryGasChange::Set(v) => self.effective_slot_gas = v,
620 DeferredRegistryGasChange::Keep => {}
621 }
622 match slot_changes.base_fee {
623 DeferredRegistryGasChange::Set(v) => self.slot_base_fee = v,
624 DeferredRegistryGasChange::Keep => {}
625 }
626 }
627}
628
629#[cfg(test)]
630mod deferred_slot_calls_tests {
631 use super::*;
632 use massa_models::amount::Amount;
633
634 #[test]
637 fn apply_changes_ignores_standalone_effective_total_gas() {
638 let slot = Slot::new(1, 0);
639 let other_slot = Slot::new(2, 0);
640
641 let mut view = DeferredSlotCalls::new(slot);
642 view.effective_slot_gas = 3;
643 view.slot_base_fee = Amount::from_raw(7);
644
645 let mut changes = DeferredCallRegistryChanges::default();
646 changes.set_effective_total_gas(42);
647 changes.set_effective_slot_gas(other_slot, 99);
648
649 view.apply_changes(&changes);
650
651 assert_eq!(view.effective_slot_gas, 3);
652 assert_eq!(view.slot_base_fee, Amount::from_raw(7));
653 assert!(view.slot_calls.is_empty());
654 }
655
656 #[test]
657 fn apply_changes_applies_slot_local_fields() {
658 let slot = Slot::new(1, 0);
659 let mut view = DeferredSlotCalls::new(slot);
660
661 let mut changes = DeferredCallRegistryChanges::default();
662 changes.set_effective_slot_gas(slot, 55);
663 changes.set_slot_base_fee(slot, Amount::from_raw(9));
664 changes.set_effective_total_gas(100); view.apply_changes(&changes);
667
668 assert_eq!(view.effective_slot_gas, 55);
669 assert_eq!(view.slot_base_fee, Amount::from_raw(9));
670 }
671}