sui_types/effects/
effects_v2.rs

1// Copyright (c) Mysten Labs, Inc.
2// SPDX-License-Identifier: Apache-2.0
3
4use super::object_change::{AccumulatorWriteV1, ObjectIn, ObjectOut};
5use super::{EffectsObjectChange, IDOperation, ObjectChange};
6use crate::accumulator_event::AccumulatorEvent;
7use crate::accumulator_root::AccumulatorObjId;
8use crate::base_types::{
9    EpochId, ObjectDigest, ObjectID, ObjectRef, SequenceNumber, SuiAddress, TransactionDigest,
10    VersionDigest,
11};
12use crate::digests::{EffectsAuxDataDigest, TransactionEventsDigest};
13use crate::effects::{InputConsensusObject, TransactionEffectsAPI};
14use crate::execution::SharedInput;
15use crate::execution_status::{ExecutionFailureStatus, ExecutionStatus, MoveLocation};
16use crate::gas::GasCostSummary;
17#[cfg(debug_assertions)]
18use crate::is_system_package;
19use crate::object::{OBJECT_START_VERSION, Owner};
20use crate::transaction::SharedObjectMutability;
21use serde::{Deserialize, Serialize};
22#[cfg(debug_assertions)]
23use std::collections::HashSet;
24use std::collections::{BTreeMap, BTreeSet};
25
26/// The response from processing a transaction or a certified transaction
27#[derive(Eq, PartialEq, Clone, Debug, Serialize, Deserialize)]
28pub struct TransactionEffectsV2 {
29    /// The status of the execution
30    pub(crate) status: ExecutionStatus,
31    /// The epoch when this transaction was executed.
32    pub(crate) executed_epoch: EpochId,
33    pub(crate) gas_used: GasCostSummary,
34    /// The transaction digest
35    pub(crate) transaction_digest: TransactionDigest,
36    /// The updated gas object reference, as an index into the `changed_objects` vector.
37    /// Having a dedicated field for convenient access.
38    /// System transaction that don't require gas will leave this as None.
39    pub(crate) gas_object_index: Option<u32>,
40    /// The digest of the events emitted during execution,
41    /// can be None if the transaction does not emit any event.
42    pub(crate) events_digest: Option<TransactionEventsDigest>,
43    /// The set of transaction digests this transaction depends on.
44    pub(crate) dependencies: Vec<TransactionDigest>,
45
46    /// The version number of all the written Move objects by this transaction.
47    pub(crate) lamport_version: SequenceNumber,
48    /// Objects whose state are changed in the object store.
49    /// This field should not be exposed to the public API.
50    /// Otherwise it will make it harder to use effects of different versions.
51    /// Note that for accumulator writes, the ObjectID here will be the dynamic field object ID
52    /// that stores the accumulator value. However this object is not really mutated
53    /// in this transaction. We just have to use an ObjectID that is unique so that
54    /// it does not conflict with any other object IDs in the changed_objects.
55    pub(crate) changed_objects: Vec<(ObjectID, EffectsObjectChange)>,
56    /// Consensus objects that are not mutated in this transaction. Unlike owned objects,
57    /// read-only consensus objects' version are not committed in the transaction,
58    /// and in order for a node to catch up and execute it without consensus sequencing,
59    /// the version needs to be committed in the effects.
60    pub(crate) unchanged_consensus_objects: Vec<(ObjectID, UnchangedConsensusKind)>,
61    /// Auxiliary data that are not protocol-critical, generated as part of the effects but are stored separately.
62    /// Storing it separately allows us to avoid bloating the effects with data that are not critical.
63    /// It also provides more flexibility on the format and type of the data.
64    pub(crate) aux_data_digest: Option<EffectsAuxDataDigest>,
65}
66
67impl TransactionEffectsAPI for TransactionEffectsV2 {
68    fn status(&self) -> &ExecutionStatus {
69        &self.status
70    }
71
72    fn into_status(self) -> ExecutionStatus {
73        self.status
74    }
75
76    fn executed_epoch(&self) -> EpochId {
77        self.executed_epoch
78    }
79
80    fn modified_at_versions(&self) -> Vec<(ObjectID, SequenceNumber)> {
81        self.changed_objects
82            .iter()
83            .filter_map(|(id, change)| {
84                if let ObjectIn::Exist(((version, _digest), _owner)) = &change.input_state {
85                    Some((*id, *version))
86                } else {
87                    None
88                }
89            })
90            .collect()
91    }
92
93    fn move_abort(&self) -> Option<(MoveLocation, u64)> {
94        let ExecutionStatus::Failure {
95            error: ExecutionFailureStatus::MoveAbort(move_location, code),
96            ..
97        } = self.status()
98        else {
99            return None;
100        };
101        Some((move_location.clone(), *code))
102    }
103
104    fn lamport_version(&self) -> SequenceNumber {
105        self.lamport_version
106    }
107
108    fn old_object_metadata(&self) -> Vec<(ObjectRef, Owner)> {
109        self.changed_objects
110            .iter()
111            .filter_map(|(id, change)| {
112                if let ObjectIn::Exist(((version, digest), owner)) = &change.input_state {
113                    Some(((*id, *version, *digest), owner.clone()))
114                } else {
115                    None
116                }
117            })
118            .collect()
119    }
120
121    fn input_consensus_objects(&self) -> Vec<InputConsensusObject> {
122        self.changed_objects
123            .iter()
124            .filter_map(|(id, change)| match &change.input_state {
125                ObjectIn::Exist(((version, digest), owner)) if owner.is_consensus() => {
126                    Some(InputConsensusObject::Mutate((*id, *version, *digest)))
127                }
128                _ => None,
129            })
130            .chain(
131                self.unchanged_consensus_objects
132                    .iter()
133                    .filter_map(|(id, change_kind)| match change_kind {
134                        UnchangedConsensusKind::ReadOnlyRoot((version, digest)) => {
135                            Some(InputConsensusObject::ReadOnly((*id, *version, *digest)))
136                        }
137                        UnchangedConsensusKind::MutateConsensusStreamEnded(seqno) => Some(
138                            InputConsensusObject::MutateConsensusStreamEnded(*id, *seqno),
139                        ),
140                        UnchangedConsensusKind::ReadConsensusStreamEnded(seqno) => {
141                            Some(InputConsensusObject::ReadConsensusStreamEnded(*id, *seqno))
142                        }
143                        UnchangedConsensusKind::Cancelled(seqno) => {
144                            Some(InputConsensusObject::Cancelled(*id, *seqno))
145                        }
146                        // We can not expose the per epoch config object as input consensus object,
147                        // since it does not require sequencing, and hence shall not be considered
148                        // as a normal input consensus object.
149                        UnchangedConsensusKind::PerEpochConfig => None,
150                    }),
151            )
152            .collect()
153    }
154
155    fn created(&self) -> Vec<(ObjectRef, Owner)> {
156        self.changed_objects
157            .iter()
158            .filter_map(|(id, change)| {
159                match (
160                    &change.input_state,
161                    &change.output_state,
162                    &change.id_operation,
163                ) {
164                    (
165                        ObjectIn::NotExist,
166                        ObjectOut::ObjectWrite((digest, owner)),
167                        IDOperation::Created,
168                    ) => Some(((*id, self.lamport_version, *digest), owner.clone())),
169                    (
170                        ObjectIn::NotExist,
171                        ObjectOut::PackageWrite((version, digest)),
172                        IDOperation::Created,
173                    ) => Some(((*id, *version, *digest), Owner::Immutable)),
174                    _ => None,
175                }
176            })
177            .collect()
178    }
179
180    fn mutated(&self) -> Vec<(ObjectRef, Owner)> {
181        self.changed_objects
182            .iter()
183            .filter_map(
184                |(id, change)| match (&change.input_state, &change.output_state) {
185                    (ObjectIn::Exist(_), ObjectOut::ObjectWrite((digest, owner))) => {
186                        Some(((*id, self.lamport_version, *digest), owner.clone()))
187                    }
188                    (ObjectIn::Exist(_), ObjectOut::PackageWrite((version, digest))) => {
189                        Some(((*id, *version, *digest), Owner::Immutable))
190                    }
191                    _ => None,
192                },
193            )
194            .collect()
195    }
196
197    fn unwrapped(&self) -> Vec<(ObjectRef, Owner)> {
198        self.changed_objects
199            .iter()
200            .filter_map(|(id, change)| {
201                match (
202                    &change.input_state,
203                    &change.output_state,
204                    &change.id_operation,
205                ) {
206                    (
207                        ObjectIn::NotExist,
208                        ObjectOut::ObjectWrite((digest, owner)),
209                        IDOperation::None,
210                    ) => Some(((*id, self.lamport_version, *digest), owner.clone())),
211                    _ => None,
212                }
213            })
214            .collect()
215    }
216
217    fn deleted(&self) -> Vec<ObjectRef> {
218        self.changed_objects
219            .iter()
220            .filter_map(|(id, change)| {
221                match (
222                    &change.input_state,
223                    &change.output_state,
224                    &change.id_operation,
225                ) {
226                    (ObjectIn::Exist(_), ObjectOut::NotExist, IDOperation::Deleted) => Some((
227                        *id,
228                        self.lamport_version,
229                        ObjectDigest::OBJECT_DIGEST_DELETED,
230                    )),
231                    _ => None,
232                }
233            })
234            .collect()
235    }
236
237    fn unwrapped_then_deleted(&self) -> Vec<ObjectRef> {
238        self.changed_objects
239            .iter()
240            .filter_map(|(id, change)| {
241                match (
242                    &change.input_state,
243                    &change.output_state,
244                    &change.id_operation,
245                ) {
246                    (ObjectIn::NotExist, ObjectOut::NotExist, IDOperation::Deleted) => Some((
247                        *id,
248                        self.lamport_version,
249                        ObjectDigest::OBJECT_DIGEST_DELETED,
250                    )),
251                    _ => None,
252                }
253            })
254            .collect()
255    }
256
257    fn wrapped(&self) -> Vec<ObjectRef> {
258        self.changed_objects
259            .iter()
260            .filter_map(|(id, change)| {
261                match (
262                    &change.input_state,
263                    &change.output_state,
264                    &change.id_operation,
265                ) {
266                    (ObjectIn::Exist(_), ObjectOut::NotExist, IDOperation::None) => Some((
267                        *id,
268                        self.lamport_version,
269                        ObjectDigest::OBJECT_DIGEST_WRAPPED,
270                    )),
271                    _ => None,
272                }
273            })
274            .collect()
275    }
276
277    fn written(&self) -> Vec<ObjectRef> {
278        self.changed_objects
279            .iter()
280            .filter_map(
281                |(id, change)| match (&change.output_state, &change.id_operation) {
282                    (ObjectOut::NotExist, IDOperation::Deleted) => Some((
283                        *id,
284                        self.lamport_version,
285                        ObjectDigest::OBJECT_DIGEST_DELETED,
286                    )),
287                    (ObjectOut::NotExist, IDOperation::None) => Some((
288                        *id,
289                        self.lamport_version,
290                        ObjectDigest::OBJECT_DIGEST_WRAPPED,
291                    )),
292                    (ObjectOut::ObjectWrite((d, _)), _) => Some((*id, self.lamport_version, *d)),
293                    (ObjectOut::PackageWrite(vd), _) => Some((*id, vd.0, vd.1)),
294                    (ObjectOut::AccumulatorWriteV1(_), _) => None,
295                    _ => None,
296                },
297            )
298            .collect()
299    }
300
301    fn transferred_from_consensus(&self) -> Vec<ObjectRef> {
302        self.changed_objects
303            .iter()
304            .filter_map(|(id, change)| {
305                match (
306                    &change.input_state,
307                    &change.output_state,
308                    &change.id_operation,
309                ) {
310                    (
311                        ObjectIn::Exist((_, Owner::ConsensusAddressOwner { .. })),
312                        ObjectOut::ObjectWrite((
313                            object_digest,
314                            Owner::AddressOwner(_) | Owner::ObjectOwner(_) | Owner::Immutable,
315                        )),
316                        IDOperation::None,
317                    ) => Some((*id, self.lamport_version, *object_digest)),
318                    _ => None,
319                }
320            })
321            .collect()
322    }
323
324    fn transferred_to_consensus(&self) -> Vec<ObjectRef> {
325        self.changed_objects
326            .iter()
327            .filter_map(|(id, change)| {
328                match (
329                    &change.input_state,
330                    &change.output_state,
331                    &change.id_operation,
332                ) {
333                    (
334                        ObjectIn::Exist((_, Owner::AddressOwner(_) | Owner::ObjectOwner(_))),
335                        ObjectOut::ObjectWrite((
336                            object_digest,
337                            Owner::ConsensusAddressOwner { .. },
338                        )),
339                        IDOperation::None,
340                    ) => Some((*id, self.lamport_version, *object_digest)),
341                    _ => None,
342                }
343            })
344            .collect()
345    }
346
347    fn consensus_owner_changed(&self) -> Vec<ObjectRef> {
348        self.changed_objects
349            .iter()
350            .filter_map(|(id, change)| {
351                match (
352                    &change.input_state,
353                    &change.output_state,
354                    &change.id_operation,
355                ) {
356                    (
357                        ObjectIn::Exist((
358                            _,
359                            Owner::ConsensusAddressOwner {
360                                owner: old_owner, ..
361                            },
362                        )),
363                        ObjectOut::ObjectWrite((
364                            object_digest,
365                            Owner::ConsensusAddressOwner {
366                                owner: new_owner, ..
367                            },
368                        )),
369                        IDOperation::None,
370                    ) if old_owner != new_owner => {
371                        Some((*id, self.lamport_version, *object_digest))
372                    }
373                    _ => None,
374                }
375            })
376            .collect()
377    }
378
379    fn object_changes(&self) -> Vec<ObjectChange> {
380        self.changed_objects
381            .iter()
382            .filter_map(|(id, change)| {
383                let input_version_digest = match &change.input_state {
384                    ObjectIn::NotExist => None,
385                    ObjectIn::Exist((vd, _)) => Some(*vd),
386                };
387
388                let output_version_digest = match &change.output_state {
389                    ObjectOut::NotExist => None,
390                    ObjectOut::ObjectWrite((d, _)) => Some((self.lamport_version, *d)),
391                    ObjectOut::PackageWrite(vd) => Some(*vd),
392                    ObjectOut::AccumulatorWriteV1(_) => {
393                        return None;
394                    }
395                };
396
397                Some(ObjectChange {
398                    id: *id,
399
400                    input_version: input_version_digest.map(|k| k.0),
401                    input_digest: input_version_digest.map(|k| k.1),
402
403                    output_version: output_version_digest.map(|k| k.0),
404                    output_digest: output_version_digest.map(|k| k.1),
405
406                    id_operation: change.id_operation,
407                })
408            })
409            .collect()
410    }
411
412    fn accumulator_events(&self) -> Vec<AccumulatorEvent> {
413        self.changed_objects
414            .iter()
415            .filter_map(|(id, change)| match &change.output_state {
416                ObjectOut::AccumulatorWriteV1(write) => Some(AccumulatorEvent::new(
417                    AccumulatorObjId::new_unchecked(*id),
418                    write.clone(),
419                )),
420                _ => None,
421            })
422            .collect()
423    }
424
425    fn gas_object(&self) -> (ObjectRef, Owner) {
426        if let Some(gas_object_index) = self.gas_object_index {
427            let entry = &self.changed_objects[gas_object_index as usize];
428            match &entry.1.output_state {
429                ObjectOut::ObjectWrite((digest, owner)) => {
430                    ((entry.0, self.lamport_version, *digest), owner.clone())
431                }
432                _ => panic!("Gas object must be an ObjectWrite in changed_objects"),
433            }
434        } else {
435            (
436                (ObjectID::ZERO, SequenceNumber::default(), ObjectDigest::MIN),
437                Owner::AddressOwner(SuiAddress::default()),
438            )
439        }
440    }
441
442    fn events_digest(&self) -> Option<&TransactionEventsDigest> {
443        self.events_digest.as_ref()
444    }
445
446    fn dependencies(&self) -> &[TransactionDigest] {
447        &self.dependencies
448    }
449
450    fn transaction_digest(&self) -> &TransactionDigest {
451        &self.transaction_digest
452    }
453
454    fn gas_cost_summary(&self) -> &GasCostSummary {
455        &self.gas_used
456    }
457
458    fn unchanged_consensus_objects(&self) -> Vec<(ObjectID, UnchangedConsensusKind)> {
459        self.unchanged_consensus_objects.clone()
460    }
461
462    fn accumulator_updates(&self) -> Vec<(ObjectID, AccumulatorWriteV1)> {
463        self.changed_objects
464            .iter()
465            .filter_map(|(id, change)| match &change.output_state {
466                ObjectOut::AccumulatorWriteV1(update) => Some((*id, update.clone())),
467                _ => None,
468            })
469            .collect()
470    }
471
472    fn status_mut_for_testing(&mut self) -> &mut ExecutionStatus {
473        &mut self.status
474    }
475
476    fn gas_cost_summary_mut_for_testing(&mut self) -> &mut GasCostSummary {
477        &mut self.gas_used
478    }
479
480    fn transaction_digest_mut_for_testing(&mut self) -> &mut TransactionDigest {
481        &mut self.transaction_digest
482    }
483
484    fn dependencies_mut_for_testing(&mut self) -> &mut Vec<TransactionDigest> {
485        &mut self.dependencies
486    }
487
488    fn unsafe_add_input_consensus_object_for_testing(&mut self, kind: InputConsensusObject) {
489        match kind {
490            InputConsensusObject::Mutate(obj_ref) => self.changed_objects.push((
491                obj_ref.0,
492                EffectsObjectChange {
493                    input_state: ObjectIn::Exist((
494                        (obj_ref.1, obj_ref.2),
495                        Owner::Shared {
496                            initial_shared_version: OBJECT_START_VERSION,
497                        },
498                    )),
499                    output_state: ObjectOut::ObjectWrite((
500                        obj_ref.2,
501                        Owner::Shared {
502                            initial_shared_version: obj_ref.1,
503                        },
504                    )),
505                    id_operation: IDOperation::None,
506                },
507            )),
508            InputConsensusObject::ReadOnly(obj_ref) => self.unchanged_consensus_objects.push((
509                obj_ref.0,
510                UnchangedConsensusKind::ReadOnlyRoot((obj_ref.1, obj_ref.2)),
511            )),
512            InputConsensusObject::ReadConsensusStreamEnded(obj_id, seqno) => {
513                self.unchanged_consensus_objects.push((
514                    obj_id,
515                    UnchangedConsensusKind::ReadConsensusStreamEnded(seqno),
516                ))
517            }
518            InputConsensusObject::MutateConsensusStreamEnded(obj_id, seqno) => {
519                self.unchanged_consensus_objects.push((
520                    obj_id,
521                    UnchangedConsensusKind::MutateConsensusStreamEnded(seqno),
522                ))
523            }
524            InputConsensusObject::Cancelled(obj_id, seqno) => self
525                .unchanged_consensus_objects
526                .push((obj_id, UnchangedConsensusKind::Cancelled(seqno))),
527        }
528    }
529
530    fn unsafe_add_deleted_live_object_for_testing(&mut self, obj_ref: ObjectRef) {
531        self.changed_objects.push((
532            obj_ref.0,
533            EffectsObjectChange {
534                input_state: ObjectIn::Exist((
535                    (obj_ref.1, obj_ref.2),
536                    Owner::AddressOwner(SuiAddress::default()),
537                )),
538                output_state: ObjectOut::ObjectWrite((
539                    obj_ref.2,
540                    Owner::AddressOwner(SuiAddress::default()),
541                )),
542                id_operation: IDOperation::None,
543            },
544        ))
545    }
546
547    fn unsafe_add_object_tombstone_for_testing(&mut self, obj_ref: ObjectRef) {
548        self.changed_objects.push((
549            obj_ref.0,
550            EffectsObjectChange {
551                input_state: ObjectIn::Exist((
552                    (obj_ref.1, obj_ref.2),
553                    Owner::AddressOwner(SuiAddress::default()),
554                )),
555                output_state: ObjectOut::NotExist,
556                id_operation: IDOperation::Deleted,
557            },
558        ))
559    }
560}
561
562impl TransactionEffectsV2 {
563    pub fn new(
564        status: ExecutionStatus,
565        executed_epoch: EpochId,
566        gas_used: GasCostSummary,
567        shared_objects: Vec<SharedInput>,
568        loaded_per_epoch_config_objects: BTreeSet<ObjectID>,
569        transaction_digest: TransactionDigest,
570        lamport_version: SequenceNumber,
571        changed_objects: BTreeMap<ObjectID, EffectsObjectChange>,
572        gas_object: Option<ObjectID>,
573        events_digest: Option<TransactionEventsDigest>,
574        dependencies: Vec<TransactionDigest>,
575    ) -> Self {
576        let unchanged_consensus_objects = shared_objects
577            .into_iter()
578            .filter_map(|shared_input| match shared_input {
579                SharedInput::Existing((id, version, digest)) => {
580                    if changed_objects.contains_key(&id) {
581                        None
582                    } else {
583                        Some((id, UnchangedConsensusKind::ReadOnlyRoot((version, digest))))
584                    }
585                }
586                SharedInput::ConsensusStreamEnded((id, version, mutability, _)) => {
587                    debug_assert!(!changed_objects.contains_key(&id));
588                    match mutability {
589                        SharedObjectMutability::Mutable => Some((
590                            id,
591                            UnchangedConsensusKind::MutateConsensusStreamEnded(version),
592                        )),
593                        SharedObjectMutability::Immutable => Some((
594                            id,
595                            UnchangedConsensusKind::ReadConsensusStreamEnded(version),
596                        )),
597                        // This is current unreachable, because non exclusive writes are not exposed to
598                        // user transactions yet, and so there is no way for their inputs to be deleted.
599                        SharedObjectMutability::NonExclusiveWrite => Some((
600                            id,
601                            UnchangedConsensusKind::MutateConsensusStreamEnded(version),
602                        )),
603                    }
604                }
605                SharedInput::Cancelled((id, version)) => {
606                    debug_assert!(!changed_objects.contains_key(&id));
607                    Some((id, UnchangedConsensusKind::Cancelled(version)))
608                }
609            })
610            .chain(
611                loaded_per_epoch_config_objects
612                    .into_iter()
613                    .map(|id| (id, UnchangedConsensusKind::PerEpochConfig)),
614            )
615            .collect();
616        let changed_objects: Vec<_> = changed_objects.into_iter().collect();
617
618        let gas_object_index = gas_object.map(|gas_id| {
619            changed_objects
620                .iter()
621                .position(|(id, _)| id == &gas_id)
622                .unwrap() as u32
623        });
624
625        let result = Self {
626            status,
627            executed_epoch,
628            gas_used,
629            transaction_digest,
630            lamport_version,
631            changed_objects,
632            unchanged_consensus_objects,
633            gas_object_index,
634            events_digest,
635            dependencies,
636            aux_data_digest: None,
637        };
638        #[cfg(debug_assertions)]
639        result.check_invariant();
640
641        result
642    }
643
644    /// This function demonstrates what's the invariant of the effects.
645    /// It also documents the semantics of different combinations in object changes.
646    #[cfg(debug_assertions)]
647    fn check_invariant(&self) {
648        let mut unique_ids = HashSet::new();
649        for (id, change) in &self.changed_objects {
650            assert!(unique_ids.insert(*id));
651            match (
652                &change.input_state,
653                &change.output_state,
654                &change.id_operation,
655            ) {
656                (ObjectIn::NotExist, ObjectOut::NotExist, IDOperation::Created) => {
657                    // created and then wrapped Move object.
658                }
659                (ObjectIn::NotExist, ObjectOut::NotExist, IDOperation::Deleted) => {
660                    // unwrapped and then deleted Move object.
661                }
662                (ObjectIn::NotExist, ObjectOut::ObjectWrite((_, owner)), IDOperation::None) => {
663                    // unwrapped Move object.
664                    // It's not allowed to make an object shared after unwrapping.
665                    assert!(!owner.is_shared());
666                }
667                (ObjectIn::NotExist, ObjectOut::ObjectWrite(..), IDOperation::Created) => {
668                    // created Move object.
669                }
670                (ObjectIn::NotExist, ObjectOut::PackageWrite(_), IDOperation::Created) => {
671                    // created Move package or user Move package upgrade.
672                }
673                (
674                    ObjectIn::Exist(((old_version, _), old_owner)),
675                    ObjectOut::NotExist,
676                    IDOperation::None,
677                ) => {
678                    // wrapped.
679                    assert!(old_version.value() < self.lamport_version.value());
680                    assert!(
681                        !old_owner.is_shared() && !old_owner.is_immutable(),
682                        "Cannot wrap shared or immutable object"
683                    );
684                }
685                (
686                    ObjectIn::Exist(((old_version, _), old_owner)),
687                    ObjectOut::NotExist,
688                    IDOperation::Deleted,
689                ) => {
690                    // deleted.
691                    assert!(old_version.value() < self.lamport_version.value());
692                    assert!(!old_owner.is_immutable(), "Cannot delete immutable object");
693                }
694                (
695                    ObjectIn::Exist(((old_version, old_digest), old_owner)),
696                    ObjectOut::ObjectWrite((new_digest, new_owner)),
697                    IDOperation::None,
698                ) => {
699                    // mutated.
700                    assert!(old_version.value() < self.lamport_version.value());
701                    assert_ne!(old_digest, new_digest);
702                    assert!(!old_owner.is_immutable(), "Cannot mutate immutable object");
703                    if old_owner.is_shared() {
704                        assert!(new_owner.is_shared(), "Cannot un-share an object");
705                    } else {
706                        assert!(!new_owner.is_shared(), "Cannot share an existing object");
707                    }
708                }
709                (
710                    ObjectIn::Exist(((old_version, old_digest), old_owner)),
711                    ObjectOut::PackageWrite((new_version, new_digest)),
712                    IDOperation::None,
713                ) => {
714                    // system package upgrade.
715                    assert!(
716                        old_owner.is_immutable() && is_system_package(*id),
717                        "Must be a system package"
718                    );
719                    assert_eq!(old_version.value() + 1, new_version.value());
720                    assert_ne!(old_digest, new_digest);
721                }
722                (ObjectIn::NotExist, ObjectOut::AccumulatorWriteV1(_), IDOperation::None) => {
723                    // This is an accumulator write.
724                }
725                _ => {
726                    panic!("Impossible object change: {:?}, {:?}", id, change);
727                }
728            }
729        }
730        // Make sure that gas object exists in changed_objects.
731        let (_, owner) = self.gas_object();
732        assert!(matches!(owner, Owner::AddressOwner(_)));
733
734        for (id, _) in &self.unchanged_consensus_objects {
735            assert!(
736                unique_ids.insert(*id),
737                "Duplicate object id: {:?}\n{:#?}",
738                id,
739                self
740            );
741        }
742    }
743}
744
745impl Default for TransactionEffectsV2 {
746    fn default() -> Self {
747        Self {
748            status: ExecutionStatus::Success,
749            executed_epoch: 0,
750            gas_used: GasCostSummary::default(),
751            transaction_digest: TransactionDigest::default(),
752            lamport_version: SequenceNumber::default(),
753            changed_objects: vec![],
754            unchanged_consensus_objects: vec![],
755            gas_object_index: None,
756            events_digest: None,
757            dependencies: vec![],
758            aux_data_digest: None,
759        }
760    }
761}
762
763#[derive(Eq, PartialEq, Clone, Debug, Serialize, Deserialize)]
764pub enum UnchangedConsensusKind {
765    /// Read-only consensus objects from the input. We don't really need ObjectDigest
766    /// for protocol correctness, but it will make it easier to verify untrusted read.
767    ReadOnlyRoot(VersionDigest),
768    /// Objects with ended consensus streams that appear mutably/owned in the input.
769    MutateConsensusStreamEnded(SequenceNumber),
770    /// Objects with ended consensus streams objects that appear as read-only in the input.
771    ReadConsensusStreamEnded(SequenceNumber),
772    /// Consensus objects in cancelled transaction. The sequence number embed cancellation reason.
773    Cancelled(SequenceNumber),
774    /// Read of a per-epoch config object that should remain the same during an epoch.
775    PerEpochConfig,
776}
sui_types/effects/effects_v2.rs

sui_types/effects/
effects_v2.rs
