Skip to main content

ave_core/governance/
mod.rs

1//! # Governance module.
2//!
3
4use crate::{
5    approval::{
6        persist::{ApprPersist, InitApprPersist},
7        types::VotationType,
8    },
9    db::Storable,
10    evaluation::{
11        compiler::{Compiler, CompilerMessage},
12        schema::{EvaluationSchema, EvaluationSchemaMessage},
13        worker::{EvalWorker, EvalWorkerMessage},
14    },
15    governance::{
16        data::GovernanceData,
17        events::GovernanceEvent,
18        model::{
19            CreatorQuantity, HashThisRole, ProtocolTypes, Quorum, RoleTypes,
20            Schema,
21        },
22        role_register::{RoleRegister, RoleRegisterMessage},
23        sn_register::SnRegister,
24        subject_register::{SubjectRegister, SubjectRegisterMessage},
25        witnesses_register::{
26            WitnessesRegister, WitnessesRegisterMessage, WitnessesType,
27        },
28    },
29    helpers::{db::ExternalDB, network::service::NetworkSender, sink::AveSink},
30    model::{
31        common::{emit_fail, get_last_event, subject::make_obsolete},
32        event::{Protocols, ValidationMetadata},
33    },
34    node::{Node, NodeMessage, TransferSubject, register::RegisterMessage},
35    subject::{
36        DataForSink, EventLedgerDataForSink, Metadata, SignedLedger, Subject,
37        SubjectMetadata,
38        error::SubjectError,
39        sinkdata::{SinkData, SinkDataMessage},
40    },
41    system::ConfigHelper,
42    validation::{
43        request::LastData,
44        schema::{ValidationSchema, ValidationSchemaMessage},
45        worker::{ValiWorker, ValiWorkerMessage},
46    },
47};
48
49use ave_actors::{
50    Actor, ActorContext, ActorError, ActorPath, ChildAction, Handler, Message,
51    Response, Sink,
52};
53use ave_common::{
54    Namespace, SchemaType, ValueWrapper,
55    identity::{DigestIdentifier, HashAlgorithm, PublicKey, hash_borsh},
56    request::EventRequest,
57    schematype::ReservedWords,
58};
59
60use async_trait::async_trait;
61use ave_actors::{FullPersistence, PersistentActor};
62use borsh::{BorshDeserialize, BorshSerialize};
63use json_patch::{Patch, patch};
64use serde::{Deserialize, Serialize};
65use tracing::{Span, debug, error, info_span, warn};
66
67use std::{
68    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
69    sync::Arc,
70};
71
72pub mod data;
73pub mod error;
74pub mod events;
75pub mod model;
76pub mod role_register;
77pub mod sn_register;
78pub mod subject_register;
79pub mod witnesses_register;
80
81pub struct RolesUpdate {
82    pub appr_quorum: Option<Quorum>,
83    pub new_approvers: Vec<PublicKey>,
84    pub remove_approvers: Vec<PublicKey>,
85
86    pub eval_quorum: HashMap<SchemaType, Quorum>,
87    pub new_evaluators: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
88    pub remove_evaluators: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
89
90    pub vali_quorum: HashMap<SchemaType, Quorum>,
91    pub new_validators: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
92    pub remove_validators: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
93
94    pub new_creator: HashMap<
95        (SchemaType, String, PublicKey),
96        (CreatorQuantity, Vec<WitnessesType>),
97    >,
98    pub remove_creator: HashSet<(SchemaType, String, PublicKey)>,
99
100    pub new_witnesses: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
101    pub remove_witnesses: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
102}
103
104pub struct RolesUpdateConfirm {
105    pub new_approver: Option<PublicKey>,
106    pub remove_approver: PublicKey,
107
108    pub new_evaluator: Option<PublicKey>,
109    pub remove_evaluators: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
110
111    pub new_validator: Option<PublicKey>,
112    pub remove_validators: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
113
114    pub remove_creator: HashSet<(SchemaType, String, PublicKey)>,
115    pub remove_witnesses: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
116}
117
118pub struct RolesUpdateRemove {
119    pub witnesses: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
120    pub creator: HashSet<(SchemaType, String, PublicKey)>,
121    pub approvers: Vec<PublicKey>,
122    pub evaluators: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
123    pub validators: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
124}
125
126pub struct CreatorRoleUpdate {
127    pub new_creator: HashMap<
128        (SchemaType, String, PublicKey),
129        (CreatorQuantity, BTreeSet<String>),
130    >,
131
132    pub update_creator_quantity:
133        HashSet<(SchemaType, String, PublicKey, CreatorQuantity)>,
134
135    pub update_creator_witnesses:
136        HashSet<(SchemaType, String, PublicKey, BTreeSet<String>)>,
137
138    pub remove_creator: HashSet<(SchemaType, String, PublicKey)>,
139}
140
141#[derive(Default, Debug, Serialize, Deserialize, Clone)]
142pub struct Governance {
143    #[serde(skip)]
144    pub our_key: Arc<PublicKey>,
145    #[serde(skip)]
146    pub hash: Option<HashAlgorithm>,
147    pub subject_metadata: SubjectMetadata,
148    pub properties: GovernanceData,
149}
150
151impl BorshSerialize for Governance {
152    fn serialize<W: std::io::Write>(
153        &self,
154        writer: &mut W,
155    ) -> std::io::Result<()> {
156        // Serialize only the fields we want to persist, skipping 'owner'
157        BorshSerialize::serialize(&self.subject_metadata, writer)?;
158        BorshSerialize::serialize(&self.properties, writer)?;
159
160        Ok(())
161    }
162}
163
164impl BorshDeserialize for Governance {
165    fn deserialize_reader<R: std::io::Read>(
166        reader: &mut R,
167    ) -> std::io::Result<Self> {
168        // Deserialize the persisted fields
169        let subject_metadata = SubjectMetadata::deserialize_reader(reader)?;
170        let properties = GovernanceData::deserialize_reader(reader)?;
171
172        // Create a default/placeholder KeyPair for 'owner'
173        // This will be replaced by the actual owner during actor initialization
174        let our_key = Arc::new(PublicKey::default());
175        let hash = None;
176
177        Ok(Self {
178            hash,
179            our_key,
180            subject_metadata,
181            properties,
182        })
183    }
184}
185
186#[async_trait]
187impl Subject for Governance {
188    async fn update_sn(
189        &self,
190        ctx: &mut ActorContext<Self>,
191    ) -> Result<(), ActorError> {
192        let witnesses_register = ctx
193            .get_child::<WitnessesRegister>("witnesses_register")
194            .await?;
195
196        witnesses_register
197            .tell(WitnessesRegisterMessage::UpdateSnGov {
198                sn: self.subject_metadata.sn,
199            })
200            .await
201    }
202
203    async fn eol(
204        &self,
205        ctx: &mut ActorContext<Self>,
206    ) -> Result<(), ActorError> {
207        let node = ctx.get_parent::<Node>().await?;
208        node.tell(NodeMessage::EOLSubject {
209            subject_id: self.subject_metadata.subject_id.clone(),
210            i_owner: *self.our_key == self.subject_metadata.owner,
211        })
212        .await
213    }
214
215    async fn reject(
216        &self,
217        ctx: &mut ActorContext<Self>,
218        _gov_version: u64,
219    ) -> Result<(), ActorError> {
220        let node = ctx.get_parent::<Node>().await?;
221        node.tell(NodeMessage::RejectTransfer(
222            self.subject_metadata.subject_id.clone(),
223        ))
224        .await
225    }
226
227    async fn confirm(
228        &self,
229        ctx: &mut ActorContext<Self>,
230        _new_owner: PublicKey,
231        _gov_version: u64,
232    ) -> Result<(), ActorError> {
233        let node = ctx.get_parent::<Node>().await?;
234        node.tell(NodeMessage::ConfirmTransfer(
235            self.subject_metadata.subject_id.clone(),
236        ))
237        .await
238    }
239
240    async fn transfer(
241        &self,
242        ctx: &mut ActorContext<Self>,
243        new_owner: PublicKey,
244        _gov_version: u64,
245    ) -> Result<(), ActorError> {
246        let node = ctx.get_parent::<Node>().await?;
247        node.tell(NodeMessage::TransferSubject(TransferSubject {
248            name: self.subject_metadata.name.clone(),
249            subject_id: self.subject_metadata.subject_id.clone(),
250            new_owner: new_owner.clone(),
251            actual_owner: self.subject_metadata.owner.clone(),
252        }))
253        .await
254    }
255
256    async fn get_last_ledger(
257        &self,
258        ctx: &mut ActorContext<Self>,
259    ) -> Result<Option<SignedLedger>, ActorError> {
260        get_last_event(ctx).await
261    }
262
263    fn apply_patch(
264        &mut self,
265        json_patch: ValueWrapper,
266    ) -> Result<(), ActorError> {
267        let patch_json = serde_json::from_value::<Patch>(json_patch.0)
268            .map_err(|e| {
269                let error = SubjectError::PatchConversionFailed {
270                    details: e.to_string(),
271                };
272                error!(
273                    error = %e,
274                    subject_id = %self.subject_metadata.subject_id,
275                    "Failed to convert patch from JSON"
276                );
277                ActorError::Functional {
278                    description: error.to_string(),
279                }
280            })?;
281
282        let mut properties = self.properties.to_value_wrapper();
283
284        patch(&mut properties.0, &patch_json).map_err(|e| {
285            let error = SubjectError::PatchApplicationFailed {
286                details: e.to_string(),
287            };
288            error!(
289                error = %e,
290                subject_id = %self.subject_metadata.subject_id,
291                "Failed to apply patch to properties"
292            );
293            ActorError::Functional {
294                description: error.to_string(),
295            }
296        })?;
297
298        self.properties = serde_json::from_value::<GovernanceData>(
299            properties.0,
300        )
301        .map_err(|e| {
302            let error = SubjectError::GovernanceDataConversionFailed {
303                details: e.to_string(),
304            };
305            error!(
306                error = %e,
307                subject_id = %self.subject_metadata.subject_id,
308                "Failed to convert properties to GovernanceData"
309            );
310            ActorError::Functional {
311                description: error.to_string(),
312            }
313        })?;
314
315        debug!(
316            subject_id = %self.subject_metadata.subject_id,
317            "Patch applied successfully"
318        );
319
320        Ok(())
321    }
322
323    async fn manager_new_ledger_events(
324        &mut self,
325        ctx: &mut ActorContext<Self>,
326        events: Vec<SignedLedger>,
327    ) -> Result<(), ActorError> {
328        let Some(network) = ctx
329            .system()
330            .get_helper::<Arc<NetworkSender>>("network")
331            .await
332        else {
333            return Err(ActorError::Helper {
334                name: "network".to_owned(),
335                reason: "Not found".to_owned(),
336            });
337        };
338
339        let Some(hash) = self.hash else {
340            return Err(ActorError::FunctionalCritical {
341                description: "Hash algorithm is None".to_string(),
342            });
343        };
344
345        let current_sn = self.subject_metadata.sn;
346        let current_new_owner_some = self.subject_metadata.new_owner.is_some();
347        let i_current_new_owner = self.subject_metadata.new_owner.clone()
348            == Some((*self.our_key).clone());
349        let current_owner = self.subject_metadata.owner.clone();
350
351        let current_properties = self.properties.clone();
352
353        if let Err(e) = self.verify_new_ledger_events(ctx, events, &hash).await
354        {
355            if let ActorError::Functional { description } = e.clone() {
356                warn!(
357                    error = %description,
358                    subject_id = %self.subject_metadata.subject_id,
359                    sn = self.subject_metadata.sn,
360                    "Error verifying new ledger events"
361                );
362
363                // Falló en la creación
364                if self.subject_metadata.sn == 0 {
365                    return Err(e);
366                }
367            } else {
368                error!(
369                    error = %e,
370                    subject_id = %self.subject_metadata.subject_id,
371                    sn = self.subject_metadata.sn,
372                    "Critical error verifying new ledger events"
373                );
374                return Err(e);
375            }
376        };
377
378        if current_sn < self.subject_metadata.sn {
379            let old_gov = current_properties;
380            if !self.subject_metadata.active {
381                if current_owner == *self.our_key {
382                    Self::down_owner(ctx).await?;
383                } else {
384                    Self::down_not_owner(ctx, &old_gov, self.our_key.clone())
385                        .await?;
386                }
387
388                let old_schemas_eval = old_gov
389                    .schemas_name(ProtocolTypes::Evaluation, &self.our_key);
390
391                Self::down_compilers_schemas(ctx, &old_schemas_eval).await?;
392
393                let old_schemas_val = old_gov
394                    .schemas_name(ProtocolTypes::Validation, &self.our_key);
395
396                Self::down_schemas(ctx, &old_schemas_eval, &old_schemas_val)
397                    .await?;
398            } else {
399                let new_owner_some = self.subject_metadata.new_owner.is_some();
400                let i_new_owner = self.subject_metadata.new_owner.clone()
401                    == Some((*self.our_key).clone());
402                let mut up_not_owner: bool = false;
403                let mut up_owner: bool = false;
404
405                if current_owner == *self.our_key {
406                    // Eramos dueños
407                    if current_owner != self.subject_metadata.owner {
408                        // Ya no somos dueño
409                        if !current_new_owner_some && !i_new_owner {
410                            // Si antes new owner false
411                            up_not_owner = true;
412                        } else if current_new_owner_some && i_new_owner {
413                            up_owner = true;
414                        }
415                    } else {
416                        // Seguimos siendo dueños
417                        if current_new_owner_some && !new_owner_some {
418                            up_owner = true;
419                        } else if !current_new_owner_some && new_owner_some {
420                            up_not_owner = true;
421                        }
422                    }
423                } else {
424                    // No eramos dueño
425                    if current_owner != self.subject_metadata.owner
426                        && self.subject_metadata.owner == *self.our_key
427                    {
428                        // Ahora Somos dueños
429                        if !new_owner_some && !i_current_new_owner {
430                            // new owner false
431                            up_owner = true;
432                        } else if new_owner_some && i_current_new_owner {
433                            up_not_owner = true;
434                        }
435                    } else if i_current_new_owner && !i_new_owner {
436                        up_not_owner = true;
437                    } else if !i_current_new_owner && i_new_owner {
438                        up_owner = true;
439                    }
440                }
441
442                if up_not_owner {
443                    Self::down_owner(ctx).await?;
444                    self.up_not_owner(ctx, &hash, &network).await?;
445                } else if up_owner {
446                    Self::down_not_owner(ctx, &old_gov, self.our_key.clone())
447                        .await?;
448                    self.up_owner(ctx, &hash, &network).await?;
449                }
450
451                // Seguimos sin ser owner ni new owner,
452                // pero tenemos que ver si tenemos un rol nuevo.
453                if !up_not_owner
454                    && !up_owner
455                    && *self.our_key != self.subject_metadata.owner
456                {
457                    self.up_down_not_owner(ctx, &old_gov, &hash, &network)
458                        .await?;
459                }
460
461                self.manager_schemas_compilers(ctx, &old_gov).await?;
462                self.update_childs(ctx).await?;
463            }
464
465            let _ = make_obsolete(ctx, &self.subject_metadata.subject_id).await;
466        }
467
468        if current_sn < self.subject_metadata.sn || current_sn == 0 {
469            Self::publish_sink(
470                ctx,
471                SinkDataMessage::UpdateState(Box::new(Metadata::from(
472                    self.clone(),
473                ))),
474            )
475            .await?;
476
477            self.update_sn(ctx).await?;
478        }
479
480        Ok(())
481    }
482}
483
484impl Governance {
485    async fn update_schemas(
486        &self,
487        ctx: &ActorContext<Self>,
488        schema_creators_eval: &BTreeMap<
489            SchemaType,
490            BTreeMap<PublicKey, BTreeSet<Namespace>>,
491        >,
492        schema_creators_vali: &BTreeMap<
493            SchemaType,
494            BTreeMap<PublicKey, BTreeSet<Namespace>>,
495        >,
496        update_eval: &BTreeMap<SchemaType, ValueWrapper>,
497        update_vali: &BTreeMap<SchemaType, ValueWrapper>,
498    ) -> Result<(), ActorError> {
499        for (schema_id, init_state) in update_eval.iter() {
500            let actor = ctx
501                .get_child::<EvaluationSchema>(&format!(
502                    "{}_evaluation",
503                    schema_id
504                ))
505                .await?;
506
507            actor
508                .tell(EvaluationSchemaMessage::Update {
509                    creators: schema_creators_eval
510                        .get(schema_id)
511                        .cloned()
512                        .unwrap_or_default(),
513                    sn: self.subject_metadata.sn,
514                    gov_version: self.properties.version,
515                    init_state: init_state.clone(),
516                })
517                .await?;
518        }
519
520        for (schema_id, init_state) in update_vali.iter() {
521            let actor = ctx
522                .get_child::<ValidationSchema>(&format!(
523                    "{}_validation",
524                    schema_id
525                ))
526                .await?;
527
528            actor
529                .tell(ValidationSchemaMessage::Update {
530                    creators: schema_creators_vali
531                        .get(schema_id)
532                        .cloned()
533                        .unwrap_or_default(),
534                    sn: self.subject_metadata.sn,
535                    gov_version: self.properties.version,
536                    init_state: init_state.clone(),
537                })
538                .await?;
539        }
540
541        Ok(())
542    }
543
544    async fn down_schemas(
545        ctx: &ActorContext<Self>,
546        old_schemas_eval: &BTreeSet<SchemaType>,
547        old_schemas_val: &BTreeSet<SchemaType>,
548    ) -> Result<(), ActorError> {
549        for schema_id in old_schemas_eval {
550            let actor = ctx
551                .get_child::<EvaluationSchema>(&format!(
552                    "{}_evaluation",
553                    schema_id
554                ))
555                .await?;
556            actor.ask_stop().await?;
557        }
558
559        for schema_id in old_schemas_val {
560            let actor = ctx
561                .get_child::<ValidationSchema>(&format!(
562                    "{}_validation",
563                    schema_id
564                ))
565                .await?;
566            actor.ask_stop().await?;
567        }
568
569        Ok(())
570    }
571
572    async fn up_schemas(
573        &self,
574        ctx: &mut ActorContext<Self>,
575        schema_creators_eval: &BTreeMap<
576            SchemaType,
577            BTreeMap<PublicKey, BTreeSet<Namespace>>,
578        >,
579        schema_creators_vali: &BTreeMap<
580            SchemaType,
581            BTreeMap<PublicKey, BTreeSet<Namespace>>,
582        >,
583        up_eval: &BTreeMap<SchemaType, ValueWrapper>,
584        up_vali: &BTreeMap<SchemaType, ValueWrapper>,
585        hash_network: (&HashAlgorithm, &Arc<NetworkSender>),
586    ) -> Result<(), ActorError> {
587        for (schema_id, init_state) in up_eval.iter() {
588            let eval_actor = EvaluationSchema {
589                our_key: self.our_key.clone(),
590                governance_id: self.subject_metadata.subject_id.clone(),
591                gov_version: self.properties.version,
592                sn: self.subject_metadata.sn,
593                creators: schema_creators_eval
594                    .get(schema_id)
595                    .cloned()
596                    .unwrap_or_default(),
597                schema_id: schema_id.clone(),
598                init_state: init_state.clone(),
599                hash: *hash_network.0,
600                network: hash_network.1.clone(),
601            };
602
603            ctx.create_child(&format!("{}_evaluation", schema_id), eval_actor)
604                .await?;
605        }
606
607        for (schema_id, init_state) in up_vali.iter() {
608            let vali_actor = ValidationSchema {
609                our_key: self.our_key.clone(),
610                governance_id: self.subject_metadata.subject_id.clone(),
611                gov_version: self.properties.version,
612                sn: self.subject_metadata.sn,
613                creators: schema_creators_vali
614                    .get(schema_id)
615                    .cloned()
616                    .unwrap_or_default(),
617                schema_id: schema_id.clone(),
618                init_state: init_state.clone(),
619                hash: *hash_network.0,
620                network: hash_network.1.clone(),
621            };
622
623            ctx.create_child(&format!("{}_validation", schema_id), vali_actor)
624                .await?;
625        }
626
627        Ok(())
628    }
629
630    async fn manager_schemas_compilers(
631        &self,
632        ctx: &mut ActorContext<Self>,
633        old_gov: &GovernanceData,
634    ) -> Result<(), ActorError> {
635        let Some(network) = ctx
636            .system()
637            .get_helper::<Arc<NetworkSender>>("network")
638            .await
639        else {
640            return Err(ActorError::Helper {
641                name: "network".to_owned(),
642                reason: "Not found".to_owned(),
643            });
644        };
645
646        let Some(hash) = self.hash else {
647            return Err(ActorError::FunctionalCritical {
648                description: "Hash algorithm is None".to_string(),
649            });
650        };
651
652        let (old_schemas_eval, new_schemas_eval) = {
653            let old_schemas_eval =
654                old_gov.schemas_name(ProtocolTypes::Evaluation, &self.our_key);
655
656            let new_schemas_eval = self
657                .properties
658                .schemas(ProtocolTypes::Evaluation, &self.our_key);
659
660            // Compilers
661            // Bajamos los compilers que ya no soy evaluador
662            let down = old_schemas_eval
663                .clone()
664                .iter()
665                .filter(|x| !new_schemas_eval.contains_key(x))
666                .cloned()
667                .collect();
668            Self::down_compilers_schemas(ctx, &down).await?;
669
670            // Subimos los compilers que soy nuevo evaluador
671            let up = new_schemas_eval
672                .clone()
673                .iter()
674                .filter(|x| !old_schemas_eval.contains(x.0))
675                .map(|x| (x.0.clone(), x.1.clone()))
676                .collect();
677
678            Self::up_compilers_schemas(
679                ctx,
680                &up,
681                self.subject_metadata.subject_id.clone(),
682                &hash,
683            )
684            .await?;
685
686            // Compilo los nuevos contratos en el caso de que hayan sido modificados, sino no afecta.
687            let current = new_schemas_eval
688                .clone()
689                .iter()
690                .filter(|x| old_schemas_eval.contains(x.0))
691                .map(|x| (x.0.clone(), x.1.clone()))
692                .collect();
693
694            Self::compile_schemas(
695                ctx,
696                current,
697                self.subject_metadata.subject_id.clone(),
698            )
699            .await?;
700
701            (
702                old_schemas_eval,
703                new_schemas_eval
704                    .iter()
705                    .map(|x| (x.0.clone(), x.1.initial_value.clone()))
706                    .collect::<BTreeMap<SchemaType, ValueWrapper>>(),
707            )
708        };
709        let old_schemas_vali =
710            old_gov.schemas_name(ProtocolTypes::Validation, &self.our_key);
711
712        let new_schemas_vali = self
713            .properties
714            .schemas_init_value(ProtocolTypes::Validation, &self.our_key);
715
716        // Bajar schemas
717        let down_eval = old_schemas_eval
718            .clone()
719            .iter()
720            .filter(|x| !new_schemas_eval.contains_key(x))
721            .cloned()
722            .collect();
723
724        let down_vali = old_schemas_vali
725            .clone()
726            .iter()
727            .filter(|x| !new_schemas_vali.contains_key(x))
728            .cloned()
729            .collect();
730
731        Self::down_schemas(ctx, &down_eval, &down_vali).await?;
732
733        // Subir los nuevos schemas
734        let schemas_namespace_eval = self
735            .properties
736            .schemas_namespace(ProtocolTypes::Evaluation, &self.our_key);
737
738        let schema_creators_eval = self
739            .properties
740            .schema_creators_namespace(schemas_namespace_eval);
741
742        let up_eval = new_schemas_eval
743            .clone()
744            .iter()
745            .filter(|x| !old_schemas_eval.contains(x.0))
746            .map(|x| (x.0.clone(), x.1.clone()))
747            .collect::<BTreeMap<SchemaType, ValueWrapper>>();
748
749        let schemas_namespace_vali = self
750            .properties
751            .schemas_namespace(ProtocolTypes::Validation, &self.our_key);
752
753        let schema_creators_vali = self
754            .properties
755            .schema_creators_namespace(schemas_namespace_vali);
756
757        let up_vali = new_schemas_vali
758            .clone()
759            .iter()
760            .filter(|x| !old_schemas_vali.contains(x.0))
761            .map(|x| (x.0.clone(), x.1.clone()))
762            .collect::<BTreeMap<SchemaType, ValueWrapper>>();
763        // Up
764        self.up_schemas(
765            ctx,
766            &schema_creators_eval,
767            &schema_creators_vali,
768            &up_eval,
769            &up_vali,
770            (&hash, &network),
771        )
772        .await?;
773
774        // Update
775        let update_eval = new_schemas_eval
776            .clone()
777            .iter()
778            .filter(|x| old_schemas_eval.contains(x.0))
779            .map(|x| (x.0.clone(), x.1.clone()))
780            .collect::<BTreeMap<SchemaType, ValueWrapper>>();
781
782        let update_vali = new_schemas_vali
783            .clone()
784            .iter()
785            .filter(|x| old_schemas_vali.contains(x.0))
786            .map(|x| (x.0.clone(), x.1.clone()))
787            .collect::<BTreeMap<SchemaType, ValueWrapper>>();
788
789        self.update_schemas(
790            ctx,
791            &schema_creators_eval,
792            &schema_creators_vali,
793            &update_eval,
794            &update_vali,
795        )
796        .await
797    }
798
799    async fn update_childs(
800        &self,
801        ctx: &ActorContext<Self>,
802    ) -> Result<(), ActorError> {
803        if let Ok(evaluator) = ctx.get_child::<EvalWorker>("evaluator").await {
804            evaluator
805                .tell(EvalWorkerMessage::UpdateGovVersion {
806                    gov_version: self.properties.version,
807                })
808                .await?;
809        }
810
811        if let Ok(validator) = ctx.get_child::<ValiWorker>("validator").await {
812            validator
813                .tell(ValiWorkerMessage::UpdateGovVersion {
814                    gov_version: self.properties.version,
815                })
816                .await?;
817        }
818
819        Ok(())
820    }
821
822    async fn build_childs(
823        &self,
824        ctx: &mut ActorContext<Self>,
825        hash: &HashAlgorithm,
826        network: &Arc<NetworkSender>,
827    ) -> Result<(), ActorError> {
828        // If subject is a governance
829        let owner = *self.our_key == self.subject_metadata.owner;
830        let new_owner = self.subject_metadata.new_owner.is_some();
831        let i_new_owner =
832            self.subject_metadata.new_owner == Some((*self.our_key).clone());
833
834        if new_owner {
835            if i_new_owner {
836                self.up_owner(ctx, hash, network).await?;
837            } else {
838                self.up_not_owner(ctx, hash, network).await?;
839            }
840        } else if owner {
841            self.up_owner(ctx, hash, network).await?;
842        } else {
843            self.up_not_owner(ctx, hash, network).await?;
844        }
845
846        let new_schemas_eval = {
847            let schemas = self
848                .properties
849                .schemas(ProtocolTypes::Evaluation, &self.our_key);
850            Self::up_compilers_schemas(
851                ctx,
852                &schemas,
853                self.subject_metadata.subject_id.clone(),
854                hash,
855            )
856            .await?;
857
858            schemas
859                .iter()
860                .map(|x| (x.0.clone(), x.1.initial_value.clone()))
861                .collect::<BTreeMap<SchemaType, ValueWrapper>>()
862        };
863
864        let schemas_namespace_eval = self
865            .properties
866            .schemas_namespace(ProtocolTypes::Evaluation, &self.our_key);
867
868        let schema_creators_eval = self
869            .properties
870            .schema_creators_namespace(schemas_namespace_eval);
871
872        let schemas_namespace_vali = self
873            .properties
874            .schemas_namespace(ProtocolTypes::Validation, &self.our_key);
875
876        let schema_creators_vali = self
877            .properties
878            .schema_creators_namespace(schemas_namespace_vali);
879
880        let new_schemas_vali = self
881            .properties
882            .schemas_init_value(ProtocolTypes::Validation, &self.our_key);
883
884        self.up_schemas(
885            ctx,
886            &schema_creators_eval,
887            &schema_creators_vali,
888            &new_schemas_eval,
889            &new_schemas_vali,
890            (hash, network),
891        )
892        .await
893    }
894
895    async fn up_not_owner(
896        &self,
897        ctx: &mut ActorContext<Self>,
898        hash: &HashAlgorithm,
899        network: &Arc<NetworkSender>,
900    ) -> Result<(), ActorError> {
901        let node_key = self.subject_metadata.new_owner.as_ref().map_or_else(
902            || self.subject_metadata.owner.clone(),
903            |new_owner| new_owner.clone(),
904        );
905
906        if self.properties.has_this_role(HashThisRole::Gov {
907            who: (*self.our_key).clone(),
908            role: RoleTypes::Validator,
909        }) {
910            // If we are a validator
911            let validator = ValiWorker {
912                node_key: node_key.clone(),
913                our_key: self.our_key.clone(),
914                init_state: None,
915                governance_id: self.subject_metadata.subject_id.clone(),
916                gov_version: self.properties.version,
917                sn: self.subject_metadata.sn,
918                hash: *hash,
919                network: network.clone(),
920                stop: false,
921            };
922            ctx.create_child("validator", validator).await?;
923        }
924
925        if self.properties.has_this_role(HashThisRole::Gov {
926            who: (*self.our_key).clone(),
927            role: RoleTypes::Evaluator,
928        }) {
929            // If we are a evaluator
930            let evaluator = EvalWorker {
931                node_key: node_key.clone(),
932                our_key: self.our_key.clone(),
933                governance_id: self.subject_metadata.subject_id.clone(),
934                gov_version: self.properties.version,
935                sn: self.subject_metadata.sn,
936                init_state: None,
937                hash: *hash,
938                network: network.clone(),
939                stop: false,
940            };
941            ctx.create_child("evaluator", evaluator).await?;
942        }
943
944        if self.properties.has_this_role(HashThisRole::Gov {
945            who: (*self.our_key).clone(),
946            role: RoleTypes::Approver,
947        }) {
948            let always_accept = if let Some(config) =
949                ctx.system().get_helper::<ConfigHelper>("config").await
950            {
951                config.always_accept
952            } else {
953                return Err(ActorError::Helper {
954                    name: "config".to_owned(),
955                    reason: "Not found".to_owned(),
956                });
957            };
958
959            let pass_votation = if always_accept {
960                VotationType::AlwaysAccept
961            } else {
962                VotationType::Manual
963            };
964
965            let init_approver = InitApprPersist {
966                our_key: self.our_key.clone(),
967                node_key: node_key.clone(),
968                subject_id: self.subject_metadata.subject_id.clone(),
969                pass_votation,
970                helpers: (*hash, network.clone()),
971            };
972
973            ctx.create_child("approver", ApprPersist::initial(init_approver))
974                .await?;
975        }
976
977        Ok(())
978    }
979
980    async fn up_down_not_owner(
981        &self,
982        ctx: &mut ActorContext<Self>,
983        old_gov: &GovernanceData,
984        hash: &HashAlgorithm,
985        network: &Arc<NetworkSender>,
986    ) -> Result<(), ActorError> {
987        let node_key = self.subject_metadata.new_owner.as_ref().map_or_else(
988            || self.subject_metadata.owner.clone(),
989            |new_owner| new_owner.clone(),
990        );
991
992        let old_val = old_gov.has_this_role(HashThisRole::Gov {
993            who: (*self.our_key).clone(),
994            role: RoleTypes::Validator,
995        });
996
997        let new_val = self.properties.has_this_role(HashThisRole::Gov {
998            who: (*self.our_key).clone(),
999            role: RoleTypes::Validator,
1000        });
1001
1002        match (old_val, new_val) {
1003            (true, false) => {
1004                let actor = ctx.get_child::<ValiWorker>("validator").await?;
1005                actor.ask_stop().await?;
1006            }
1007            (false, true) => {
1008                // If we are a validator
1009                let validator = ValiWorker {
1010                    node_key: node_key.clone(),
1011                    our_key: self.our_key.clone(),
1012                    init_state: None,
1013                    governance_id: self.subject_metadata.subject_id.clone(),
1014                    gov_version: self.properties.version,
1015                    sn: self.subject_metadata.sn,
1016                    hash: *hash,
1017                    network: network.clone(),
1018                    stop: false,
1019                };
1020                ctx.create_child("validator", validator).await?;
1021            }
1022            _ => {}
1023        };
1024
1025        let old_eval = old_gov.has_this_role(HashThisRole::Gov {
1026            who: (*self.our_key).clone(),
1027            role: RoleTypes::Evaluator,
1028        });
1029
1030        let new_eval = self.properties.has_this_role(HashThisRole::Gov {
1031            who: (*self.our_key).clone(),
1032            role: RoleTypes::Evaluator,
1033        });
1034
1035        match (old_eval, new_eval) {
1036            (true, false) => {
1037                let actor = ctx.get_child::<EvalWorker>("evaluator").await?;
1038
1039                actor.ask_stop().await?;
1040            }
1041            (false, true) => {
1042                let evaluator = EvalWorker {
1043                    node_key: node_key.clone(),
1044                    our_key: self.our_key.clone(),
1045                    governance_id: self.subject_metadata.subject_id.clone(),
1046                    gov_version: self.properties.version,
1047                    sn: self.subject_metadata.sn,
1048                    init_state: None,
1049                    hash: *hash,
1050                    network: network.clone(),
1051                    stop: false,
1052                };
1053                ctx.create_child("evaluator", evaluator).await?;
1054            }
1055            _ => {}
1056        };
1057
1058        let old_appr = old_gov.has_this_role(HashThisRole::Gov {
1059            who: (*self.our_key).clone(),
1060            role: RoleTypes::Approver,
1061        });
1062
1063        let new_appr = self.properties.has_this_role(HashThisRole::Gov {
1064            who: (*self.our_key).clone(),
1065            role: RoleTypes::Approver,
1066        });
1067
1068        match (old_appr, new_appr) {
1069            (true, false) => {
1070                let actor = ctx.get_child::<ApprPersist>("approver").await?;
1071
1072                actor.ask_stop().await?;
1073            }
1074            (false, true) => {
1075                let always_accept = if let Some(config) =
1076                    ctx.system().get_helper::<ConfigHelper>("config").await
1077                {
1078                    config.always_accept
1079                } else {
1080                    return Err(ActorError::Helper {
1081                        name: "config".to_owned(),
1082                        reason: "Not found".to_owned(),
1083                    });
1084                };
1085
1086                let pass_votation = if always_accept {
1087                    VotationType::AlwaysAccept
1088                } else {
1089                    VotationType::Manual
1090                };
1091
1092                let init_approver = InitApprPersist {
1093                    our_key: self.our_key.clone(),
1094                    node_key: node_key.clone(),
1095                    subject_id: self.subject_metadata.subject_id.clone(),
1096                    pass_votation,
1097                    helpers: (*hash, network.clone()),
1098                };
1099
1100                ctx.create_child(
1101                    "approver",
1102                    ApprPersist::initial(init_approver),
1103                )
1104                .await?;
1105            }
1106            _ => {}
1107        };
1108
1109        Ok(())
1110    }
1111
1112    async fn down_not_owner(
1113        ctx: &ActorContext<Self>,
1114        gov: &GovernanceData,
1115        our_key: Arc<PublicKey>,
1116    ) -> Result<(), ActorError> {
1117        if gov.has_this_role(HashThisRole::Gov {
1118            who: (*our_key).clone(),
1119            role: RoleTypes::Validator,
1120        }) {
1121            let actor = ctx.get_child::<ValiWorker>("validator").await?;
1122
1123            actor.ask_stop().await?;
1124        }
1125
1126        if gov.has_this_role(HashThisRole::Gov {
1127            who: (*our_key).clone(),
1128            role: RoleTypes::Evaluator,
1129        }) {
1130            let actor = ctx.get_child::<EvalWorker>("evaluator").await?;
1131
1132            actor.ask_stop().await?;
1133        }
1134
1135        if gov.has_this_role(HashThisRole::Gov {
1136            who: (*our_key).clone(),
1137            role: RoleTypes::Approver,
1138        }) {
1139            let actor = ctx.get_child::<ApprPersist>("approver").await?;
1140
1141            actor.ask_stop().await?;
1142        }
1143
1144        Ok(())
1145    }
1146
1147    async fn up_owner(
1148        &self,
1149        ctx: &mut ActorContext<Self>,
1150        hash: &HashAlgorithm,
1151        network: &Arc<NetworkSender>,
1152    ) -> Result<(), ActorError> {
1153        let always_accept = if let Some(config) =
1154            ctx.system().get_helper::<ConfigHelper>("config").await
1155        {
1156            config.always_accept
1157        } else {
1158            return Err(ActorError::Helper {
1159                name: "config".to_string(),
1160                reason: "Not Found".to_string(),
1161            });
1162        };
1163        let pass_votation = if always_accept {
1164            VotationType::AlwaysAccept
1165        } else {
1166            VotationType::Manual
1167        };
1168
1169        let init_approver = InitApprPersist {
1170            our_key: self.our_key.clone(),
1171            node_key: (*self.our_key).clone(),
1172            subject_id: self.subject_metadata.subject_id.clone(),
1173            pass_votation,
1174            helpers: (*hash, network.clone()),
1175        };
1176
1177        ctx.create_child("approver", ApprPersist::initial(init_approver))
1178            .await?;
1179
1180        Ok(())
1181    }
1182
1183    async fn down_owner(ctx: &ActorContext<Self>) -> Result<(), ActorError> {
1184        let actor = ctx.get_child::<ApprPersist>("approver").await?;
1185        actor.ask_stop().await?;
1186
1187        Ok(())
1188    }
1189
1190    async fn up_compilers_schemas(
1191        ctx: &mut ActorContext<Self>,
1192        schemas: &BTreeMap<SchemaType, Schema>,
1193        subject_id: DigestIdentifier,
1194        hash: &HashAlgorithm,
1195    ) -> Result<(), ActorError> {
1196        let contracts_path = if let Some(config) =
1197            ctx.system().get_helper::<ConfigHelper>("config").await
1198        {
1199            config.contracts_path
1200        } else {
1201            return Err(ActorError::Helper {
1202                name: "config".to_string(),
1203                reason: "Not Found".to_string(),
1204            });
1205        };
1206
1207        for (id, schema) in schemas {
1208            let actor_name = format!("{}_compiler", id);
1209
1210            let compiler =
1211                ctx.create_child(&actor_name, Compiler::new(*hash)).await?;
1212
1213            let Schema {
1214                contract,
1215                initial_value,
1216            } = schema;
1217
1218            compiler
1219                .tell(CompilerMessage::Compile {
1220                    contract_name: format!("{}_{}", subject_id, id),
1221                    contract: contract.clone(),
1222                    initial_value: initial_value.0.clone(),
1223                    contract_path: contracts_path
1224                        .join("contracts")
1225                        .join(format!("{}_{}", subject_id, id)),
1226                })
1227                .await?;
1228        }
1229
1230        Ok(())
1231    }
1232
1233    async fn down_compilers_schemas(
1234        ctx: &ActorContext<Self>,
1235        schemas: &BTreeSet<SchemaType>,
1236    ) -> Result<(), ActorError> {
1237        for schema_id in schemas.iter() {
1238            let actor = ctx
1239                .get_child::<Compiler>(&format!("{}_compiler", schema_id))
1240                .await?;
1241
1242            actor.ask_stop().await?;
1243        }
1244
1245        Ok(())
1246    }
1247
1248    async fn compile_schemas(
1249        ctx: &ActorContext<Self>,
1250        schemas: HashMap<SchemaType, Schema>,
1251        subject_id: DigestIdentifier,
1252    ) -> Result<(), ActorError> {
1253        let contracts_path = if let Some(config) =
1254            ctx.system().get_helper::<ConfigHelper>("config").await
1255        {
1256            config.contracts_path
1257        } else {
1258            return Err(ActorError::Helper {
1259                name: "config".to_owned(),
1260                reason: "Not found".to_owned(),
1261            });
1262        };
1263
1264        for (id, schema) in schemas {
1265            let actor = ctx
1266                .get_child::<Compiler>(&format!("{}_compiler", id))
1267                .await?;
1268
1269            actor
1270                .tell(CompilerMessage::Compile {
1271                    contract_name: format!("{}_{}", subject_id, id),
1272                    contract: schema.contract.clone(),
1273                    initial_value: schema.initial_value.0.clone(),
1274                    contract_path: contracts_path
1275                        .join("contracts")
1276                        .join(format!("{}_{}", subject_id, id)),
1277                })
1278                .await?;
1279        }
1280
1281        Ok(())
1282    }
1283
1284    fn build_creators_register_fact(
1285        &self,
1286        new_creator: HashMap<
1287            (SchemaType, String, PublicKey),
1288            (CreatorQuantity, Vec<WitnessesType>),
1289        >,
1290        remove_creator: HashSet<(SchemaType, String, PublicKey)>,
1291        creator_update: CreatorRoleUpdate,
1292        new_witnesses: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
1293        remove_witnesses: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
1294    ) -> (SubjectRegisterMessage, WitnessesRegisterMessage) {
1295        let mut data: Vec<(PublicKey, SchemaType, String, CreatorQuantity)> =
1296            vec![];
1297
1298        let mut new_creator_data: HashMap<
1299            (SchemaType, String, PublicKey),
1300            Vec<WitnessesType>,
1301        > = HashMap::new();
1302
1303        let mut update_creator_witnesses_data: HashSet<(
1304            SchemaType,
1305            String,
1306            PublicKey,
1307            Vec<WitnessesType>,
1308        )> = HashSet::new();
1309
1310        for ((schema_id, ns, creator), (quantity, witnesses)) in
1311            new_creator.iter()
1312        {
1313            data.push((
1314                creator.clone(),
1315                schema_id.clone(),
1316                ns.clone(),
1317                quantity.clone(),
1318            ));
1319
1320            new_creator_data.insert(
1321                (schema_id.clone(), ns.clone(), creator.clone()),
1322                witnesses.clone(),
1323            );
1324        }
1325
1326        for (schema_id, ns, creator) in remove_creator.iter() {
1327            data.push((
1328                creator.clone(),
1329                schema_id.clone(),
1330                ns.clone(),
1331                CreatorQuantity::Quantity(0),
1332            ));
1333        }
1334
1335        for ((schema_id, ns, creator), (quantity, creator_witnesses)) in
1336            creator_update.new_creator.iter()
1337        {
1338            data.push((
1339                creator.clone(),
1340                schema_id.clone(),
1341                ns.clone(),
1342                quantity.clone(),
1343            ));
1344
1345            let mut witnesses = vec![];
1346            for witness in creator_witnesses.iter() {
1347                if witness == &ReservedWords::Witnesses.to_string() {
1348                    witnesses.push(WitnessesType::Witnesses);
1349                } else if let Some(w) = self.properties.members.get(witness) {
1350                    witnesses.push(WitnessesType::User(w.clone()));
1351                }
1352            }
1353
1354            new_creator_data.insert(
1355                (schema_id.clone(), ns.clone(), creator.clone()),
1356                witnesses,
1357            );
1358        }
1359
1360        for (schema_id, ns, creator, quantity) in
1361            creator_update.update_creator_quantity.iter()
1362        {
1363            data.push((
1364                creator.clone(),
1365                schema_id.clone(),
1366                ns.clone(),
1367                quantity.clone(),
1368            ));
1369        }
1370
1371        for (schema_id, ns, creator, creator_witnesses) in
1372            creator_update.update_creator_witnesses.iter()
1373        {
1374            let mut witnesses = vec![];
1375            for witness in creator_witnesses.iter() {
1376                if witness == &ReservedWords::Witnesses.to_string() {
1377                    witnesses.push(WitnessesType::Witnesses);
1378                } else if let Some(w) = self.properties.members.get(witness) {
1379                    witnesses.push(WitnessesType::User(w.clone()));
1380                }
1381            }
1382
1383            update_creator_witnesses_data.insert((
1384                schema_id.clone(),
1385                ns.clone(),
1386                creator.clone(),
1387                witnesses,
1388            ));
1389        }
1390
1391        for (schema_id, ns, creator) in creator_update.remove_creator.iter() {
1392            data.push((
1393                creator.clone(),
1394                schema_id.clone(),
1395                ns.clone(),
1396                CreatorQuantity::Quantity(0),
1397            ));
1398        }
1399
1400        (
1401            SubjectRegisterMessage::RegisterData {
1402                gov_version: self.properties.version,
1403                data,
1404            },
1405            WitnessesRegisterMessage::UpdateCreatorsWitnessesFact {
1406                version: self.properties.version,
1407                new_creator: new_creator_data,
1408                remove_creator,
1409                update_creator_witnesses: update_creator_witnesses_data,
1410                new_witnesses,
1411                remove_witnesses,
1412            },
1413        )
1414    }
1415
1416    fn build_creators_register_confirm(
1417        &self,
1418        remove_creator: HashSet<(SchemaType, String, PublicKey)>,
1419        remove_witnesses: HashMap<(SchemaType, PublicKey), Vec<Namespace>>,
1420    ) -> (SubjectRegisterMessage, WitnessesRegisterMessage) {
1421        let data: Vec<(PublicKey, SchemaType, String, CreatorQuantity)> =
1422            remove_creator
1423                .iter()
1424                .map(|x| {
1425                    (
1426                        x.2.clone(),
1427                        x.0.clone(),
1428                        x.1.clone(),
1429                        CreatorQuantity::Quantity(0),
1430                    )
1431                })
1432                .collect();
1433        (
1434            SubjectRegisterMessage::RegisterData {
1435                gov_version: self.properties.version,
1436                data,
1437            },
1438            WitnessesRegisterMessage::UpdateCreatorsWitnessesConfirm {
1439                version: self.properties.version,
1440                remove_creator,
1441                remove_witnesses,
1442            },
1443        )
1444    }
1445
1446    async fn first_role_register(
1447        &self,
1448        ctx: &ActorContext<Self>,
1449    ) -> Result<(), ActorError> {
1450        let actor = ctx.get_child::<RoleRegister>("role_register").await?;
1451
1452        actor
1453            .tell(RoleRegisterMessage::UpdateFact {
1454                version: 0,
1455                appr_quorum: Some(Quorum::Majority),
1456                eval_quorum: HashMap::from([(
1457                    SchemaType::Governance,
1458                    Quorum::Majority,
1459                )]),
1460                new_approvers: vec![self.subject_metadata.owner.clone()],
1461                new_evaluators: HashMap::from([(
1462                    (
1463                        SchemaType::Governance,
1464                        self.subject_metadata.owner.clone(),
1465                    ),
1466                    vec![Namespace::new()],
1467                )]),
1468                new_validators: HashMap::from([(
1469                    (
1470                        SchemaType::Governance,
1471                        self.subject_metadata.owner.clone(),
1472                    ),
1473                    vec![Namespace::new()],
1474                )]),
1475                remove_approvers: vec![],
1476                remove_evaluators: HashMap::new(),
1477                remove_validators: HashMap::new(),
1478                vali_quorum: HashMap::from([(
1479                    SchemaType::Governance,
1480                    Quorum::Majority,
1481                )]),
1482            })
1483            .await
1484    }
1485
1486    async fn update_gov_version(
1487        &self,
1488        ctx: &ActorContext<Self>,
1489    ) -> Result<(), ActorError> {
1490        let actor = ctx.get_child::<RoleRegister>("role_register").await?;
1491
1492        actor
1493            .tell(RoleRegisterMessage::UpdateVersion {
1494                version: self.properties.version + 1,
1495            })
1496            .await
1497    }
1498
1499    async fn update_registers_fact(
1500        &self,
1501        ctx: &ActorContext<Self>,
1502        update: RolesUpdate,
1503        creator_update: CreatorRoleUpdate,
1504    ) -> Result<(), ActorError> {
1505        let RolesUpdate {
1506            appr_quorum,
1507            new_approvers,
1508            remove_approvers,
1509            eval_quorum,
1510            new_evaluators,
1511            remove_evaluators,
1512            vali_quorum,
1513            new_validators,
1514            remove_validators,
1515            new_creator,
1516            remove_creator,
1517            new_witnesses,
1518            remove_witnesses,
1519        } = update;
1520
1521        let actor = ctx.get_child::<RoleRegister>("role_register").await?;
1522        actor
1523            .tell(RoleRegisterMessage::UpdateFact {
1524                version: self.properties.version,
1525                appr_quorum,
1526                eval_quorum,
1527                new_approvers,
1528                new_evaluators,
1529                new_validators,
1530                remove_approvers,
1531                remove_evaluators,
1532                remove_validators,
1533                vali_quorum,
1534            })
1535            .await?;
1536
1537        let (subj_msg, wit_msg) = self.build_creators_register_fact(
1538            new_creator,
1539            remove_creator,
1540            creator_update,
1541            new_witnesses,
1542            remove_witnesses,
1543        );
1544
1545        let actor =
1546            ctx.get_child::<SubjectRegister>("subject_register").await?;
1547
1548        actor.tell(subj_msg).await?;
1549
1550        let actor = ctx
1551            .get_child::<WitnessesRegister>("witnesses_register")
1552            .await?;
1553
1554        actor.tell(wit_msg).await
1555    }
1556
1557    async fn update_registers_confirm(
1558        &self,
1559        ctx: &ActorContext<Self>,
1560        update: RolesUpdateConfirm,
1561    ) -> Result<(), ActorError> {
1562        let RolesUpdateConfirm {
1563            new_approver,
1564            remove_approver,
1565            new_evaluator,
1566            remove_evaluators,
1567            new_validator,
1568            remove_validators,
1569            remove_creator,
1570            remove_witnesses,
1571        } = update;
1572
1573        let actor = ctx.get_child::<RoleRegister>("role_register").await?;
1574        actor
1575            .tell(RoleRegisterMessage::UpdateConfirm {
1576                version: self.properties.version,
1577                new_approver,
1578                remove_approver,
1579                new_evaluator,
1580                remove_evaluators,
1581                new_validator,
1582                remove_validators,
1583            })
1584            .await?;
1585
1586        let (subj_msg, wit_msg) = self
1587            .build_creators_register_confirm(remove_creator, remove_witnesses);
1588
1589        let actor =
1590            ctx.get_child::<SubjectRegister>("subject_register").await?;
1591
1592        actor.tell(subj_msg).await?;
1593
1594        let actor = ctx
1595            .get_child::<WitnessesRegister>("witnesses_register")
1596            .await?;
1597
1598        actor.tell(wit_msg).await
1599    }
1600
1601    async fn verify_new_ledger_events(
1602        &mut self,
1603        ctx: &mut ActorContext<Self>,
1604        events: Vec<SignedLedger>,
1605        hash: &HashAlgorithm,
1606    ) -> Result<(), ActorError> {
1607        let mut iter = events.into_iter();
1608        let last_ledger = get_last_event(ctx).await?;
1609
1610        let mut last_ledger = if let Some(last_ledger) = last_ledger {
1611            last_ledger
1612        } else {
1613            let Some(first) = iter.next() else {
1614                return Ok(());
1615            };
1616            if let Err(e) = Self::verify_first_ledger_event(
1617                ctx,
1618                &first,
1619                hash,
1620                Metadata::from(self.clone()),
1621            )
1622            .await
1623            {
1624                return Err(ActorError::Functional {
1625                    description: e.to_string(),
1626                });
1627            }
1628
1629            self.on_event(first.clone(), ctx).await;
1630            Self::register(
1631                ctx,
1632                RegisterMessage::RegisterGov {
1633                    gov_id: self.subject_metadata.subject_id.to_string(),
1634                    name: self.subject_metadata.name.clone(),
1635                    description: self.subject_metadata.description.clone(),
1636                },
1637            )
1638            .await?;
1639
1640            self.first_role_register(ctx).await?;
1641
1642            Self::event_to_sink(
1643                ctx,
1644                DataForSink {
1645                    gov_id: None,
1646                    subject_id: self.subject_metadata.subject_id.to_string(),
1647                    sn: self.subject_metadata.sn,
1648                    owner: self.subject_metadata.owner.to_string(),
1649                    namespace: String::default(),
1650                    schema_id: self.subject_metadata.schema_id.clone(),
1651                    issuer: first
1652                        .content()
1653                        .event_request
1654                        .signature()
1655                        .signer
1656                        .to_string(),
1657                    event_ledger_timestamp: first
1658                        .signature()
1659                        .timestamp
1660                        .as_nanos(),
1661                    event_request_timestamp: first
1662                        .content()
1663                        .event_request
1664                        .signature()
1665                        .timestamp
1666                        .as_nanos(),
1667                    gov_version: first.content().gov_version,
1668                    event_data_ledger: EventLedgerDataForSink::build(
1669                        &first.content().protocols,
1670                        &self.properties.to_value_wrapper().0,
1671                    ),
1672                },
1673                first.content().event_request.content(),
1674            )
1675            .await?;
1676
1677            first
1678        };
1679
1680        for event in iter {
1681            let actual_ledger_hash =
1682                hash_borsh(&*hash.hasher(), &last_ledger.0).map_err(|e| {
1683                    ActorError::FunctionalCritical {
1684                        description: format!(
1685                            "Can not creacte actual ledger event hash: {}",
1686                            e
1687                        ),
1688                    }
1689                })?;
1690            let last_data = LastData {
1691                gov_version: last_ledger.content().gov_version,
1692                vali_data: last_ledger
1693                    .content()
1694                    .protocols
1695                    .get_validation_data(),
1696            };
1697
1698            let last_event_is_ok = match Self::verify_new_ledger_event(
1699                ctx,
1700                &event,
1701                Metadata::from(self.clone()),
1702                actual_ledger_hash,
1703                last_data,
1704                hash,
1705            )
1706            .await
1707            {
1708                Ok(last_event_is_ok) => last_event_is_ok,
1709                Err(e) => {
1710                    // Check if it's a sequence number error
1711                    if matches!(e, SubjectError::InvalidSequenceNumber { .. }) {
1712                        // El evento que estamos aplicando no es el siguiente.
1713                        continue;
1714                    } else {
1715                        return Err(ActorError::Functional {
1716                            description: e.to_string(),
1717                        });
1718                    }
1719                }
1720            };
1721            let (update_fact, update_confirm) = if last_event_is_ok {
1722                match event.content().event_request.content().clone() {
1723                    EventRequest::Transfer(transfer_request) => {
1724                        self.transfer(
1725                            ctx,
1726                            transfer_request.new_owner.clone(),
1727                            0,
1728                        )
1729                        .await?;
1730
1731                        self.update_gov_version(ctx).await?;
1732                    }
1733                    EventRequest::Reject(..) => {
1734                        self.reject(ctx, 0).await?;
1735
1736                        self.update_gov_version(ctx).await?;
1737                    }
1738                    EventRequest::EOL(..) => {
1739                        self.eol(ctx).await?;
1740
1741                        Self::register(
1742                            ctx,
1743                            RegisterMessage::EOLGov {
1744                                gov_id: self
1745                                    .subject_metadata
1746                                    .subject_id
1747                                    .to_string(),
1748                            },
1749                        )
1750                        .await?;
1751
1752                        self.update_gov_version(ctx).await?;
1753                    }
1754                    _ => {}
1755                };
1756
1757                Self::event_to_sink(
1758                    ctx,
1759                    DataForSink {
1760                        gov_id: None,
1761                        subject_id: self
1762                            .subject_metadata
1763                            .subject_id
1764                            .to_string(),
1765                        sn: self.subject_metadata.sn,
1766                        owner: self.subject_metadata.owner.to_string(),
1767                        namespace: String::default(),
1768                        schema_id: self.subject_metadata.schema_id.clone(),
1769                        issuer: event
1770                            .content()
1771                            .event_request
1772                            .signature()
1773                            .signer
1774                            .to_string(),
1775                        event_ledger_timestamp: event
1776                            .signature()
1777                            .timestamp
1778                            .as_nanos(),
1779                        event_request_timestamp: event
1780                            .content()
1781                            .event_request
1782                            .signature()
1783                            .timestamp
1784                            .as_nanos(),
1785                        gov_version: event.content().gov_version,
1786                        event_data_ledger: EventLedgerDataForSink::build(
1787                            &event.content().protocols,
1788                            &self.properties.to_value_wrapper().0,
1789                        ),
1790                    },
1791                    event.content().event_request.content(),
1792                )
1793                .await?;
1794
1795                let update_confirm = if let EventRequest::Confirm(..) =
1796                    &event.content().event_request.content()
1797                {
1798                    self.confirm(ctx, event.signature().signer.clone(), 0)
1799                        .await?;
1800
1801                    if let Some(new_owner_key) =
1802                        &self.subject_metadata.new_owner
1803                    {
1804                        Some(self.properties.roles_update_remove_confirm(
1805                            &self.subject_metadata.owner,
1806                            new_owner_key,
1807                        ))
1808                    } else {
1809                        None
1810                    }
1811                } else {
1812                    None
1813                };
1814
1815                let update_fact = if let EventRequest::Fact(fact_request) =
1816                    &event.content().event_request.content()
1817                {
1818                    let governance_event = serde_json::from_value::<GovernanceEvent>(fact_request.payload.0.clone()).map_err(|e| {
1819                            ActorError::FunctionalCritical{description: format!("Can not convert payload into governance event in governance fact event: {}", e)}
1820                        })?;
1821
1822                    let rm_members = governance_event
1823                        .members
1824                        .as_ref()
1825                        .map_or_else(|| None, |members| members.remove.clone());
1826
1827                    let rm_schemas = governance_event
1828                        .schemas
1829                        .as_ref()
1830                        .map_or_else(|| None, |schemas| schemas.remove.clone());
1831
1832                    let rm_roles =
1833                        if rm_members.is_some() || rm_schemas.is_some() {
1834                            Some(self.properties.roles_update_remove_fact(
1835                                rm_members, rm_schemas,
1836                            ))
1837                        } else {
1838                            None
1839                        };
1840
1841                    let creator_update = governance_event
1842                        .update_creator_change(
1843                            &self.properties.members,
1844                            &self.properties.roles_schema,
1845                        );
1846
1847                    Some((governance_event, creator_update, rm_roles))
1848                } else {
1849                    None
1850                };
1851                (update_fact, update_confirm)
1852            } else {
1853                (None, None)
1854            };
1855
1856            // Aplicar evento.
1857            self.on_event(event.clone(), ctx).await;
1858
1859            if let Some((event, creator_update, rm_roles)) = update_fact {
1860                let update =
1861                    event.roles_update_fact(&self.properties.members, rm_roles);
1862
1863                self.update_registers_fact(ctx, update, creator_update)
1864                    .await?;
1865            }
1866
1867            if let Some(update_confirm) = update_confirm {
1868                self.update_registers_confirm(ctx, update_confirm).await?;
1869            }
1870
1871            // Acutalizar último evento.
1872            last_ledger = event.clone();
1873        }
1874
1875        Ok(())
1876    }
1877}
1878
1879/// Governance command.
1880#[derive(Debug, Clone)]
1881pub enum GovernanceMessage {
1882    GetMetadata,
1883    GetLedger { lo_sn: Option<u64>, hi_sn: u64 },
1884    GetLastLedger,
1885    UpdateLedger { events: Vec<SignedLedger> },
1886    GetGovernance,
1887    GetVersion,
1888}
1889
1890impl Message for GovernanceMessage {}
1891
1892#[derive(Debug, Clone)]
1893pub enum GovernanceResponse {
1894    /// The subject metadata.
1895    Metadata(Box<Metadata>),
1896    UpdateResult(u64, PublicKey, Option<PublicKey>),
1897    Ledger {
1898        ledger: Vec<SignedLedger>,
1899        is_all: bool,
1900    },
1901    LastLedger {
1902        ledger_event: Box<Option<SignedLedger>>,
1903    },
1904    Governance(Box<GovernanceData>),
1905    NewCompilers(Vec<SchemaType>),
1906    Sn(u64),
1907    Version(u64),
1908    Ok,
1909}
1910impl Response for GovernanceResponse {}
1911
1912#[async_trait]
1913impl Actor for Governance {
1914    type Event = SignedLedger;
1915    type Message = GovernanceMessage;
1916    type Response = GovernanceResponse;
1917
1918    fn get_span(id: &str, parent_span: Option<Span>) -> tracing::Span {
1919        parent_span.map_or_else(
1920            || info_span!("Governance", id),
1921            |parent_span| info_span!(parent: parent_span, "Governance", id),
1922        )
1923    }
1924
1925    async fn pre_start(
1926        &mut self,
1927        ctx: &mut ActorContext<Self>,
1928    ) -> Result<(), ActorError> {
1929        if let Err(e) = self.init_store("governance", None, true, ctx).await {
1930            error!(
1931                error = %e,
1932                "Failed to initialize governance store"
1933            );
1934            return Err(e);
1935        }
1936
1937        let Some(hash) = self.hash else {
1938            error!("Hash algorithm not found");
1939            return Err(ActorError::FunctionalCritical {
1940                description: "Hash algorithm is None".to_string(),
1941            });
1942        };
1943
1944        let Some(ext_db): Option<Arc<ExternalDB>> =
1945            ctx.system().get_helper("ext_db").await
1946        else {
1947            error!("External database helper not found");
1948            return Err(ActorError::Helper {
1949                name: "ext_db".to_owned(),
1950                reason: "Not found".to_owned(),
1951            });
1952        };
1953
1954        let Some(ave_sink): Option<AveSink> =
1955            ctx.system().get_helper("sink").await
1956        else {
1957            error!("Sink helper not found");
1958            return Err(ActorError::Helper {
1959                name: "sink".to_owned(),
1960                reason: "Not found".to_owned(),
1961            });
1962        };
1963
1964        let Some(network) = ctx
1965            .system()
1966            .get_helper::<Arc<NetworkSender>>("network")
1967            .await
1968        else {
1969            error!("Network helper not found");
1970            return Err(ActorError::Helper {
1971                name: "network".to_owned(),
1972                reason: "Not found".to_owned(),
1973            });
1974        };
1975
1976        if self.subject_metadata.active {
1977            if let Err(e) = self.build_childs(ctx, &hash, &network).await {
1978                error!(
1979                    error = %e,
1980                    "Failed to build governance child actors"
1981                );
1982                return Err(e);
1983            }
1984
1985            let sink_actor = match ctx
1986                .create_child(
1987                    "sink_data",
1988                    SinkData {
1989                        public_key: self.our_key.to_string(),
1990                    },
1991                )
1992                .await
1993            {
1994                Ok(actor) => actor,
1995                Err(e) => {
1996                    error!(
1997                        error = %e,
1998                        "Failed to create sink_data child"
1999                    );
2000                    return Err(e);
2001                }
2002            };
2003            let sink =
2004                Sink::new(sink_actor.subscribe(), ext_db.get_sink_data());
2005            ctx.system().run_sink(sink).await;
2006
2007            let sink = Sink::new(sink_actor.subscribe(), ave_sink.clone());
2008            ctx.system().run_sink(sink).await;
2009        }
2010
2011        if let Err(e) = ctx
2012            .create_child("role_register", RoleRegister::initial(()))
2013            .await
2014        {
2015            error!(
2016                error = %e,
2017                "Failed to create role_register child"
2018            );
2019            return Err(e);
2020        }
2021
2022        if let Err(e) = ctx
2023            .create_child("subject_register", SubjectRegister::initial(()))
2024            .await
2025        {
2026            error!(
2027                error = %e,
2028                "Failed to create subject_register child"
2029            );
2030            return Err(e);
2031        }
2032
2033        if let Err(e) = ctx
2034            .create_child("sn_register", SnRegister::initial(()))
2035            .await
2036        {
2037            error!(
2038                error = %e,
2039                "Failed to create sn_register child"
2040            );
2041            return Err(e);
2042        }
2043
2044        if let Err(e) = ctx
2045            .create_child("witnesses_register", WitnessesRegister::initial(()))
2046            .await
2047        {
2048            error!(
2049                error = %e,
2050                "Failed to create witnesses_register child"
2051            );
2052            return Err(e);
2053        }
2054
2055        Ok(())
2056    }
2057}
2058
2059#[async_trait]
2060impl Handler<Self> for Governance {
2061    async fn handle_message(
2062        &mut self,
2063        _sender: ActorPath,
2064        msg: GovernanceMessage,
2065        ctx: &mut ActorContext<Self>,
2066    ) -> Result<GovernanceResponse, ActorError> {
2067        match msg {
2068            GovernanceMessage::GetVersion => {
2069                Ok(GovernanceResponse::Version(self.properties.version))
2070            }
2071            GovernanceMessage::GetLedger { lo_sn, hi_sn } => {
2072                let (ledger, is_all) =
2073                    self.get_ledger(ctx, lo_sn, hi_sn).await?;
2074                Ok(GovernanceResponse::Ledger { ledger, is_all })
2075            }
2076            GovernanceMessage::GetLastLedger => {
2077                let ledger_event = self.get_last_ledger(ctx).await?;
2078                Ok(GovernanceResponse::LastLedger {
2079                    ledger_event: Box::new(ledger_event),
2080                })
2081            }
2082            GovernanceMessage::GetMetadata => Ok(GovernanceResponse::Metadata(
2083                Box::new(Metadata::from(self.clone())),
2084            )),
2085            GovernanceMessage::UpdateLedger { events } => {
2086                let events_count = events.len();
2087                if let Err(e) =
2088                    self.manager_new_ledger_events(ctx, events).await
2089                {
2090                    warn!(
2091                        msg_type = "UpdateLedger",
2092                        error = %e,
2093                        subject_id = %self.subject_metadata.subject_id,
2094                        events_count = events_count,
2095                        "Failed to verify new ledger events"
2096                    );
2097                    return Err(e);
2098                };
2099
2100                debug!(
2101                    msg_type = "UpdateLedger",
2102                    subject_id = %self.subject_metadata.subject_id,
2103                    sn = self.subject_metadata.sn,
2104                    events_count = events_count,
2105                    "Ledger updated successfully"
2106                );
2107
2108                Ok(GovernanceResponse::UpdateResult(
2109                    self.subject_metadata.sn,
2110                    self.subject_metadata.owner.clone(),
2111                    self.subject_metadata.new_owner.clone(),
2112                ))
2113            }
2114            GovernanceMessage::GetGovernance => {
2115                Ok(GovernanceResponse::Governance(Box::new(
2116                    self.properties.clone(),
2117                )))
2118            }
2119        }
2120    }
2121
2122    async fn on_event(
2123        &mut self,
2124        event: SignedLedger,
2125        ctx: &mut ActorContext<Self>,
2126    ) {
2127        if let Err(e) = self.persist(&event, ctx).await {
2128            error!(
2129                error = %e,
2130                subject_id = %self.subject_metadata.subject_id,
2131                sn = self.subject_metadata.sn,
2132                "Failed to persist event"
2133            );
2134            emit_fail(ctx, e).await;
2135        };
2136
2137        if let Err(e) = ctx.publish_event(event).await {
2138            error!(
2139                error = %e,
2140                subject_id = %self.subject_metadata.subject_id,
2141                sn = self.subject_metadata.sn,
2142                "Failed to publish event"
2143            );
2144            emit_fail(ctx, e).await;
2145        } else {
2146            debug!(
2147                subject_id = %self.subject_metadata.subject_id,
2148                sn = self.subject_metadata.sn,
2149                "Event persisted and published successfully"
2150            );
2151        }
2152    }
2153
2154    async fn on_child_fault(
2155        &mut self,
2156        error: ActorError,
2157        ctx: &mut ActorContext<Self>,
2158    ) -> ChildAction {
2159        error!(
2160            error = %error,
2161            subject_id = %self.subject_metadata.subject_id,
2162            "Child fault occurred"
2163        );
2164        emit_fail(ctx, error).await;
2165        ChildAction::Stop
2166    }
2167}
2168
2169#[async_trait]
2170impl PersistentActor for Governance {
2171    type Persistence = FullPersistence;
2172    type InitParams = (
2173        Option<(SubjectMetadata, GovernanceData)>,
2174        Arc<PublicKey>,
2175        HashAlgorithm,
2176    );
2177
2178    fn update(&mut self, state: Self) {
2179        self.properties = state.properties;
2180        self.subject_metadata = state.subject_metadata;
2181    }
2182
2183    fn create_initial(params: Self::InitParams) -> Self {
2184        let (subject_metadata, properties) =
2185            if let Some((subject_metadata, properties)) = params.0 {
2186                (subject_metadata, properties)
2187            } else {
2188                Default::default()
2189            };
2190        Self {
2191            hash: Some(params.2),
2192            our_key: params.1,
2193            subject_metadata,
2194            properties,
2195        }
2196    }
2197
2198    fn apply(&mut self, event: &Self::Event) -> Result<(), ActorError> {
2199        match (
2200            event.content().event_request.content(),
2201            &event.content().protocols,
2202        ) {
2203            (EventRequest::Create(..), Protocols::Create { validation }) => {
2204                if let ValidationMetadata::Metadata(metadata) =
2205                    &validation.validation_metadata
2206                {
2207                    self.subject_metadata = SubjectMetadata::new(metadata);
2208                    self.properties = serde_json::from_value::<GovernanceData>(
2209                        metadata.properties.0.clone(),
2210                    )
2211                    .map_err(|e| {
2212                        error!(
2213                            event_type = "Create",
2214                            subject_id = %self.subject_metadata.subject_id,
2215                            error = %e,
2216                            "Failed to convert properties into GovernanceData"
2217                        );
2218                        ActorError::Functional { description: format!("In create event, can not convert properties into GovernanceData: {e}")}
2219                    })?;
2220
2221                    debug!(
2222                        event_type = "Create",
2223                        subject_id = %self.subject_metadata.subject_id,
2224                        sn = self.subject_metadata.sn,
2225                        "Applied create event"
2226                    );
2227                } else {
2228                    error!(
2229                        event_type = "Create",
2230                        "Validation metadata must be Metadata type"
2231                    );
2232                    return Err(ActorError::Functional { description: "In create event, validation metadata must be a Metadata".to_owned() });
2233                }
2234
2235                return Ok(());
2236            }
2237            (
2238                EventRequest::Fact(..),
2239                Protocols::GovFact {
2240                    evaluation,
2241                    approval,
2242                    ..
2243                },
2244            ) => {
2245                if let Some(eval_res) = evaluation.evaluator_res() {
2246                    if let Some(appr_res) = approval {
2247                        if appr_res.approved {
2248                            self.apply_patch(eval_res.patch)?;
2249                            debug!(
2250                                event_type = "Fact",
2251                                subject_id = %self.subject_metadata.subject_id,
2252                                approved = true,
2253                                "Applied fact event with patch"
2254                            );
2255                        } else {
2256                            debug!(
2257                                event_type = "Fact",
2258                                subject_id = %self.subject_metadata.subject_id,
2259                                approved = false,
2260                                "Fact event not approved, patch not applied"
2261                            );
2262                        }
2263                    } else {
2264                        error!(
2265                            event_type = "Fact",
2266                            subject_id = %self.subject_metadata.subject_id,
2267                            "Evaluation successful but no approval present"
2268                        );
2269                        return Err(ActorError::Functional { description: "The evaluation event was successful, but there is no approval".to_owned() });
2270                    }
2271                }
2272            }
2273            (
2274                EventRequest::Transfer(transfer_request),
2275                Protocols::Transfer { evaluation, .. },
2276            ) => {
2277                if evaluation.evaluator_res().is_some() {
2278                    self.subject_metadata.new_owner =
2279                        Some(transfer_request.new_owner.clone());
2280                    debug!(
2281                        event_type = "Transfer",
2282                        subject_id = %self.subject_metadata.subject_id,
2283                        new_owner = %transfer_request.new_owner,
2284                        "Applied transfer event"
2285                    );
2286                }
2287            }
2288            (
2289                EventRequest::Confirm(..),
2290                Protocols::GovConfirm { evaluation, .. },
2291            ) => {
2292                if let Some(eval_res) = evaluation.evaluator_res() {
2293                    if let Some(new_owner) =
2294                        self.subject_metadata.new_owner.take()
2295                    {
2296                        self.subject_metadata.owner = new_owner.clone();
2297                        self.apply_patch(eval_res.patch)?;
2298                        debug!(
2299                            event_type = "Confirm",
2300                            subject_id = %self.subject_metadata.subject_id,
2301                            new_owner = %new_owner,
2302                            "Applied confirm event with patch"
2303                        );
2304                    } else {
2305                        error!(
2306                            event_type = "Confirm",
2307                            subject_id = %self.subject_metadata.subject_id,
2308                            "New owner is None in confirm event"
2309                        );
2310                        return Err(ActorError::Functional {
2311                            description: "In confirm event, new owner is None"
2312                                .to_owned(),
2313                        });
2314                    }
2315                }
2316            }
2317            (EventRequest::Reject(..), Protocols::Reject { .. }) => {
2318                self.subject_metadata.new_owner = None;
2319                debug!(
2320                    event_type = "Reject",
2321                    subject_id = %self.subject_metadata.subject_id,
2322                    "Applied reject event"
2323                );
2324            }
2325            (EventRequest::EOL(..), Protocols::EOL { .. }) => {
2326                self.subject_metadata.active = false;
2327                debug!(
2328                    event_type = "EOL",
2329                    subject_id = %self.subject_metadata.subject_id,
2330                    "Applied EOL event"
2331                );
2332            }
2333            _ => {
2334                error!(
2335                    subject_id = %self.subject_metadata.subject_id,
2336                    "Invalid protocol data for Governance"
2337                );
2338                return Err(ActorError::Functional {
2339                    description: "Invalid protocol data for Governance"
2340                        .to_owned(),
2341                });
2342            }
2343        }
2344
2345        if event.content().protocols.is_success() {
2346            self.properties.version += 1;
2347        }
2348
2349        self.subject_metadata.sn += 1;
2350        self.subject_metadata.prev_ledger_event_hash =
2351            event.content().prev_ledger_event_hash.clone();
2352
2353        Ok(())
2354    }
2355}
2356
2357impl Storable for Governance {}