massa_deferred_calls/
lib.rs

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
20/// This module implements a new version of the Autonomous Smart Contracts. (ASC)
21/// This new version allow asynchronous calls to be registered for a specific slot and ensure his execution.
22mod 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
43// #[derive(Debug)]
44pub 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    /*
57     DB layout:
58        [DEFERRED_CALL_TOTAL_GAS] -> u128 // total currently booked gas
59        [DEFERRED_CALLS_PREFIX][slot][SLOT_TOTAL_GAS] -> u64 // total gas booked for a slot (optional, default 0, deleted when set to 0)
60        [DEFERRED_CALLS_PREFIX][slot][SLOT_BASE_FEE] -> u64 // deleted when set to 0
61        [DEFERRED_CALLS_PREFIX][slot][CALLS_TAG][id][CALL_FIELD_X_TAG] -> DeferredCalls.x // call data
62    */
63
64    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    /// Returns the DeferredSlotCalls for a given slot
83    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    /// Returns the DeferredCall for a given slot and id
118    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    /// Returns the total effective amount of gas booked for a slot
145    pub fn get_slot_gas(&self, slot: &Slot) -> u64 {
146        // By default, if it is absent, it is 0
147        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    /// Returns the base fee stored for a slot, or zero if the slot is uninitialized.
163    /// The `min_gas_cost` fallback for uninitialized slots lives in the speculative
164    /// layer, where it can be gated on the active execution component version.
165    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    /// Returns the total amount of effective gas booked
180    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            // sender address
221            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            // target slot
235            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            // target address
245            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            // target function
259            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            // parameters
273            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            // coins
283            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            // max gas
293            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            // fee
303            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        // cancelled
312        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        //Note: if a slot gas is zet to 0, delete the slot gas entry
347        // same for base fee
348
349        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                    //Note: if a slot gas is zet to 0, delete the slot gas entry
371                    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                    //Note: if a base fee is zet to 0, delete the base fee entry
390                    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            // deferred calls that has been executed successfully
424            massa_metrics::inc_deferred_calls_executed_by(changes.exec_stats.0);
425        }
426        if changes.exec_stats.1 > 0 {
427            // deferred calls that has failed
428            massa_metrics::inc_deferred_calls_failed_by(changes.exec_stats.1);
429        }
430        if changes.exec_stats.2 > 0 {
431            // deferred calls that has been cancelled
432            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            // update the number of deferred calls registered
441            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            // check for  [DEFERRED_CALLS_PREFIX][slot]
448            if let Some((_rest, slot)) = buf_to_array_ctr(
449                &serialized_key[DEFERRED_CALLS_PREFIX.len()..],
450                Slot::from_bytes_key,
451            ) {
452                // check for  [DEFERRED_CALLS_PREFIX][slot][SLOT_TOTAL_GAS]
453                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                    // check for  [DEFERRED_CALLS_PREFIX][slot][SLOT_BASE_FEE]
465                    return self
466                        .call_deserializer
467                        .amount_deserializer
468                        .deserialize::<DeserializeError>(serialized_value)
469                        .is_ok();
470                } else {
471                    // check for  [DEFERRED_CALLS_PREFIX][slot][CALLS_TAG][id][CALL_FIELD_X_TAG]
472
473                    // [DEFERRED_CALLS_PREFIX][slot][CALLS_TAG]
474                    let k = deferred_slot_call_prefix_key!(&slot.to_bytes_key());
475                    // Malformed keys must return false, not panic (bootstrap / final-state verification).
476                    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                        // Require exactly one field-tag byte after the call id.
486                        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/// Per-slot deferred-call view (calls, slot gas, base fee).
573///
574/// Registry-wide booked gas is not stored here — use
575/// DeferredCallRegistry::get_total_gas /
576/// SpeculativeDeferredCallRegistry::get_effective_total_gas.
577#[derive(Debug, Clone)]
578pub struct DeferredSlotCalls {
579    pub slot: Slot,
580    pub slot_calls: BTreeMap<DeferredCallId, DeferredCall>,
581
582    // calls gas + gas_alloc_cost
583    // effective_slot_gas doesn't include gas of cancelled calls
584    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    /// Apply slot-local registry changes onto this in-memory view.
600    ///
601    /// Only fields for [Self::slot] are applied. Registry-wide ffective_total_gas
602    /// is intentionally ignored; callers that need the global total must read it from
603    /// the registry / speculative layer (F33: avoid a second, desyncable copy here).
604    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    /// A change set with only registry-wide total gas (and/or another slot) must not
635    /// disturb this slot's local fields.
636    #[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); // global: ignored on this view
665
666        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}