ave_core/governance/
model.rs

1//! # Governance model.
2//!
3
4use ave_common::{
5    Namespace, SchemaType, ValueWrapper, identity::PublicKey,
6    schematype::ReservedWords,
7};
8use borsh::{BorshDeserialize, BorshSerialize};
9use serde::{Deserialize, Serialize};
10
11use std::{
12    collections::{BTreeSet, HashSet},
13    vec,
14};
15
16pub type MemberName = String;
17
18pub use ave_common::governance::{
19    CreatorQuantity, CreatorWitness, Member, ProtocolTypes, Quorum, Role,
20    RoleCreator,
21};
22
23/// Governance schema.
24#[derive(
25    Serialize,
26    Deserialize,
27    Clone,
28    Debug,
29    Hash,
30    PartialEq,
31    Eq,
32    BorshDeserialize,
33    BorshSerialize,
34)]
35pub struct Schema {
36    pub initial_value: ValueWrapper,
37    pub contract: String,
38    pub viewpoints: BTreeSet<String>,
39}
40
41pub struct NameCreators {
42    pub validation: Option<HashSet<String>>,
43    pub evaluation: Option<HashSet<String>>,
44}
45
46impl NameCreators {
47    pub const fn is_empty(&self) -> bool {
48        self.validation.is_none() && self.evaluation.is_none()
49    }
50}
51
52pub struct SchemaKeyCreators {
53    pub schema_id: SchemaType,
54    pub validation: Option<HashSet<PublicKey>>,
55    pub evaluation: Option<HashSet<PublicKey>>,
56}
57
58#[derive(
59    Serialize,
60    Deserialize,
61    Clone,
62    Debug,
63    PartialEq,
64    Eq,
65    Default,
66    BorshDeserialize,
67    BorshSerialize,
68)]
69pub struct RolesGov {
70    pub approver: BTreeSet<MemberName>,
71    pub evaluator: BTreeSet<MemberName>,
72    pub validator: BTreeSet<MemberName>,
73    pub witness: BTreeSet<MemberName>,
74    pub issuer: RoleGovIssuer,
75}
76
77impl RolesGov {
78    pub fn check_basic_gov(&self) -> bool {
79        self.approver.contains(&ReservedWords::Owner.to_string())
80            && self.evaluator.contains(&ReservedWords::Owner.to_string())
81            && self.validator.contains(&ReservedWords::Owner.to_string())
82            && self.witness.contains(&ReservedWords::Owner.to_string())
83            && self
84                .issuer
85                .signers
86                .contains(&ReservedWords::Owner.to_string())
87    }
88
89    pub fn remove_member_role(&mut self, remove_members: &Vec<String>) {
90        for remove in remove_members {
91            self.approver.remove(remove);
92            self.evaluator.remove(remove);
93            self.validator.remove(remove);
94            self.witness.remove(remove);
95            self.issuer.signers.remove(remove);
96        }
97    }
98
99    pub fn change_name_role(
100        &mut self,
101        chang_name_members: &Vec<(String, String)>,
102    ) {
103        for (old_name, new_name) in chang_name_members {
104            if self.approver.remove(old_name) {
105                self.approver.insert(new_name.clone());
106            };
107            if self.evaluator.remove(old_name) {
108                self.evaluator.insert(new_name.clone());
109            };
110            if self.validator.remove(old_name) {
111                self.validator.insert(new_name.clone());
112            };
113            if self.witness.remove(old_name) {
114                self.witness.insert(new_name.clone());
115            };
116            if self.issuer.signers.remove(old_name) {
117                self.issuer.signers.insert(new_name.clone());
118            };
119        }
120    }
121
122    pub fn hash_this_rol(&self, role: RoleTypes, name: &str) -> bool {
123        match role {
124            RoleTypes::Approver => self.approver.contains(name),
125            RoleTypes::Evaluator => self.evaluator.contains(name),
126            RoleTypes::Validator => self.validator.contains(name),
127            RoleTypes::Issuer => {
128                self.issuer.signers.contains(name) || self.issuer.any
129            }
130            RoleTypes::Creator => false,
131            RoleTypes::Witness => self.witness.contains(name),
132        }
133    }
134
135    pub fn get_signers(&self, role: RoleTypes) -> (Vec<String>, bool) {
136        match role {
137            RoleTypes::Evaluator => (
138                self.evaluator.iter().cloned().collect::<Vec<String>>(),
139                false,
140            ),
141            RoleTypes::Validator => (
142                self.validator.iter().cloned().collect::<Vec<String>>(),
143                false,
144            ),
145            RoleTypes::Approver => (
146                self.approver.iter().cloned().collect::<Vec<String>>(),
147                false,
148            ),
149            RoleTypes::Issuer => (
150                self.issuer.signers.iter().cloned().collect::<Vec<String>>(),
151                self.issuer.any,
152            ),
153            RoleTypes::Witness => {
154                (self.witness.iter().cloned().collect::<Vec<String>>(), false)
155            }
156            RoleTypes::Creator => (vec![], false),
157        }
158    }
159}
160
161#[derive(
162    Serialize,
163    Deserialize,
164    Clone,
165    Debug,
166    PartialEq,
167    Eq,
168    Default,
169    BorshDeserialize,
170    BorshSerialize,
171)]
172pub struct RolesTrackerSchemas {
173    pub evaluator: BTreeSet<Role>,
174    pub validator: BTreeSet<Role>,
175    pub witness: BTreeSet<Role>,
176    pub issuer: RoleSchemaIssuer,
177}
178
179impl From<RolesTrackerSchemas> for RolesSchema {
180    fn from(value: RolesTrackerSchemas) -> Self {
181        Self {
182            evaluator: value.evaluator,
183            validator: value.validator,
184            witness: value.witness,
185            creator: BTreeSet::new(),
186            issuer: value.issuer,
187        }
188    }
189}
190
191impl From<RolesSchema> for RolesTrackerSchemas {
192    fn from(value: RolesSchema) -> Self {
193        Self {
194            evaluator: value.evaluator,
195            validator: value.validator,
196            witness: value.witness,
197            issuer: value.issuer,
198        }
199    }
200}
201
202impl RolesTrackerSchemas {
203    pub fn role_namespace(
204        &self,
205        role: ProtocolTypes,
206        name: &str,
207    ) -> Vec<Namespace> {
208        let role = RoleTypes::from(role);
209        match role {
210            RoleTypes::Evaluator => self
211                .evaluator
212                .iter()
213                .filter(|x| x.name == name)
214                .map(|x| x.namespace.clone())
215                .collect(),
216            RoleTypes::Validator => self
217                .validator
218                .iter()
219                .filter(|x| x.name == name)
220                .map(|x| x.namespace.clone())
221                .collect(),
222            RoleTypes::Approver => {
223                vec![]
224            }
225            _ => unreachable!("The role is obtained from ProtocolTypes"),
226        }
227    }
228
229    pub fn hash_this_rol_not_namespace(
230        &self,
231        role: ProtocolTypes,
232        name: &str,
233    ) -> bool {
234        let role = RoleTypes::from(role);
235        match role {
236            RoleTypes::Evaluator => {
237                self.evaluator.iter().any(|x| x.name == name)
238            }
239            RoleTypes::Validator => {
240                self.validator.iter().any(|x| x.name == name)
241            }
242            RoleTypes::Approver => false,
243            _ => unreachable!("The role is obtained from ProtocolTypes"),
244        }
245    }
246
247    pub fn roles_namespace(
248        &self,
249        name: &str,
250    ) -> (Option<Vec<Namespace>>, Option<Vec<Namespace>>) {
251        let val_namespace = self
252            .validator
253            .iter()
254            .filter(|x| x.name == name)
255            .map(|x| x.namespace.clone())
256            .collect::<Vec<Namespace>>();
257        let eval_namespace = self
258            .evaluator
259            .iter()
260            .filter(|x| x.name == name)
261            .map(|x| x.namespace.clone())
262            .collect::<Vec<Namespace>>();
263
264        let val_namespace = if val_namespace.is_empty() {
265            None
266        } else {
267            Some(val_namespace)
268        };
269
270        let eval_namespace = if eval_namespace.is_empty() {
271            None
272        } else {
273            Some(eval_namespace)
274        };
275
276        (val_namespace, eval_namespace)
277    }
278
279    pub fn remove_member_role(&mut self, remove_members: &Vec<String>) {
280        for remove in remove_members {
281            self.evaluator.retain(|x| x.name != *remove);
282            self.validator.retain(|x| x.name != *remove);
283            self.witness.retain(|x| x.name != *remove);
284            self.issuer.signers.retain(|x| x.name != *remove);
285        }
286    }
287
288    pub fn change_name_role(
289        &mut self,
290        chang_name_members: &Vec<(String, String)>,
291    ) {
292        for (old_name, new_name) in chang_name_members {
293            self.evaluator = self
294                .evaluator
295                .iter()
296                .map(|x| {
297                    if x.name == *old_name {
298                        Role {
299                            name: new_name.clone(),
300                            namespace: x.namespace.clone(),
301                        }
302                    } else {
303                        x.clone()
304                    }
305                })
306                .collect();
307
308            self.validator = self
309                .validator
310                .iter()
311                .map(|x| {
312                    if x.name == *old_name {
313                        Role {
314                            name: new_name.clone(),
315                            namespace: x.namespace.clone(),
316                        }
317                    } else {
318                        x.clone()
319                    }
320                })
321                .collect();
322
323            self.witness = self
324                .witness
325                .iter()
326                .map(|x| {
327                    if x.name == *old_name {
328                        Role {
329                            name: new_name.clone(),
330                            namespace: x.namespace.clone(),
331                        }
332                    } else {
333                        x.clone()
334                    }
335                })
336                .collect();
337
338            self.issuer.signers = self
339                .issuer
340                .signers
341                .iter()
342                .map(|x| {
343                    if x.name == *old_name {
344                        Role {
345                            name: new_name.clone(),
346                            namespace: x.namespace.clone(),
347                        }
348                    } else {
349                        x.clone()
350                    }
351                })
352                .collect();
353        }
354    }
355
356    pub const fn issuer_any(&self) -> bool {
357        self.issuer.any
358    }
359
360    pub fn hash_this_rol(
361        &self,
362        role: RoleTypes,
363        namespace: Namespace,
364        name: &str,
365    ) -> bool {
366        match role {
367            RoleTypes::Evaluator => self.evaluator.iter().any(|x| {
368                let namespace_role = x.namespace.clone();
369                namespace_role.is_ancestor_or_equal_of(&namespace)
370                    && x.name == name
371            }),
372            RoleTypes::Validator => self.validator.iter().any(|x| {
373                let namespace_role = x.namespace.clone();
374                namespace_role.is_ancestor_or_equal_of(&namespace)
375                    && x.name == name
376            }),
377            RoleTypes::Witness => self.witness.iter().any(|x| {
378                let namespace_role = x.namespace.clone();
379                namespace_role.is_ancestor_or_equal_of(&namespace)
380                    && x.name == name
381            }),
382            RoleTypes::Issuer => {
383                self.issuer.signers.iter().any(|x| {
384                    let namespace_role = x.namespace.clone();
385                    namespace_role.is_ancestor_or_equal_of(&namespace)
386                        && x.name == name
387                }) || self.issuer.any
388            }
389            RoleTypes::Approver | RoleTypes::Creator => false,
390        }
391    }
392
393    pub fn get_signers(
394        &self,
395        role: RoleTypes,
396        namespace: Namespace,
397    ) -> (Vec<String>, bool) {
398        match role {
399            RoleTypes::Evaluator => (
400                self.evaluator
401                    .iter()
402                    .filter(|x| {
403                        let namespace_role = x.namespace.clone();
404                        namespace_role.is_ancestor_or_equal_of(&namespace)
405                    })
406                    .map(|x| x.name.clone())
407                    .collect::<Vec<String>>(),
408                false,
409            ),
410            RoleTypes::Validator => (
411                self.validator
412                    .iter()
413                    .filter(|x| {
414                        let namespace_role = x.namespace.clone();
415                        namespace_role.is_ancestor_or_equal_of(&namespace)
416                    })
417                    .map(|x| x.name.clone())
418                    .collect::<Vec<String>>(),
419                false,
420            ),
421            RoleTypes::Witness => (
422                self.witness
423                    .iter()
424                    .filter(|x| {
425                        let namespace_role = x.namespace.clone();
426                        namespace_role.is_ancestor_or_equal_of(&namespace)
427                    })
428                    .map(|x| x.name.clone())
429                    .collect::<Vec<String>>(),
430                false,
431            ),
432            RoleTypes::Issuer => (
433                self.issuer
434                    .signers
435                    .iter()
436                    .filter(|x| {
437                        let namespace_role = x.namespace.clone();
438                        namespace_role.is_ancestor_or_equal_of(&namespace)
439                    })
440                    .map(|x| x.name.clone())
441                    .collect::<Vec<String>>(),
442                self.issuer.any,
443            ),
444            RoleTypes::Approver | RoleTypes::Creator => (vec![], false),
445        }
446    }
447}
448
449#[derive(
450    Serialize,
451    Deserialize,
452    Clone,
453    Debug,
454    PartialEq,
455    Eq,
456    Default,
457    BorshDeserialize,
458    BorshSerialize,
459)]
460pub struct RolesSchema {
461    pub evaluator: BTreeSet<Role>,
462    pub validator: BTreeSet<Role>,
463    pub witness: BTreeSet<Role>,
464    pub creator: BTreeSet<RoleCreator>,
465    pub issuer: RoleSchemaIssuer,
466}
467
468impl RolesSchema {
469    pub fn creator_witnesses(
470        &self,
471        name: &str,
472        namespace: Namespace,
473    ) -> BTreeSet<String> {
474        self.creator
475            .get(&RoleCreator::create(name, namespace))
476            .map(|x| {
477                x.witnesses
478                    .iter()
479                    .map(|witness| witness.name.clone())
480                    .collect()
481            })
482            .unwrap_or_default()
483    }
484
485    pub fn remove_member_role(&mut self, remove_members: &Vec<String>) {
486        for remove in remove_members {
487            self.evaluator.retain(|x| x.name != *remove);
488            self.validator.retain(|x| x.name != *remove);
489            self.witness.retain(|x| x.name != *remove);
490            self.issuer.signers.retain(|x| x.name != *remove);
491            self.creator = std::mem::take(&mut self.creator)
492                .into_iter()
493                .filter(|x| x.name != *remove)
494                .map(|mut c| {
495                    c.witnesses.retain(|x| x.name != *remove);
496                    c
497                })
498                .collect();
499        }
500    }
501
502    pub fn change_name_role(
503        &mut self,
504        chang_name_members: &Vec<(String, String)>,
505    ) {
506        for (old_name, new_name) in chang_name_members {
507            self.evaluator = self
508                .evaluator
509                .iter()
510                .map(|x| {
511                    if x.name == *old_name {
512                        Role {
513                            name: new_name.clone(),
514                            namespace: x.namespace.clone(),
515                        }
516                    } else {
517                        x.clone()
518                    }
519                })
520                .collect();
521
522            self.validator = self
523                .validator
524                .iter()
525                .map(|x| {
526                    if x.name == *old_name {
527                        Role {
528                            name: new_name.clone(),
529                            namespace: x.namespace.clone(),
530                        }
531                    } else {
532                        x.clone()
533                    }
534                })
535                .collect();
536
537            self.witness = self
538                .witness
539                .iter()
540                .map(|x| {
541                    if x.name == *old_name {
542                        Role {
543                            name: new_name.clone(),
544                            namespace: x.namespace.clone(),
545                        }
546                    } else {
547                        x.clone()
548                    }
549                })
550                .collect();
551
552            self.creator = self
553                .creator
554                .iter()
555                .map(|x| {
556                    if x.name == *old_name {
557                        RoleCreator {
558                            quantity: x.quantity.clone(),
559                            name: new_name.clone(),
560                            witnesses: x
561                                .witnesses
562                                .iter()
563                                .map(|w| {
564                                    if w.name == *old_name {
565                                        CreatorWitness {
566                                            name: new_name.clone(),
567                                            viewpoints: w.viewpoints.clone(),
568                                        }
569                                    } else {
570                                        w.clone()
571                                    }
572                                })
573                                .collect(),
574                            namespace: x.namespace.clone(),
575                        }
576                    } else {
577                        let mut role = x.clone();
578                        role.witnesses = role
579                            .witnesses
580                            .iter()
581                            .map(|w| {
582                                if w.name == *old_name {
583                                    CreatorWitness {
584                                        name: new_name.clone(),
585                                        viewpoints: w.viewpoints.clone(),
586                                    }
587                                } else {
588                                    w.clone()
589                                }
590                            })
591                            .collect();
592                        role
593                    }
594                })
595                .collect();
596
597            self.issuer.signers = self
598                .issuer
599                .signers
600                .iter()
601                .map(|x| {
602                    if x.name == *old_name {
603                        Role {
604                            name: new_name.clone(),
605                            namespace: x.namespace.clone(),
606                        }
607                    } else {
608                        x.clone()
609                    }
610                })
611                .collect();
612        }
613    }
614
615    pub fn roles_creators(
616        &self,
617        name: &str,
618        not_gov_val: Option<Vec<Namespace>>,
619        not_gov_eval: Option<Vec<Namespace>>,
620    ) -> NameCreators {
621        let mut val_namespace = self
622            .validator
623            .iter()
624            .filter(|x| x.name == name)
625            .map(|x| x.namespace.clone())
626            .collect::<Vec<Namespace>>();
627        if let Some(mut not_gov_val) = not_gov_val {
628            val_namespace.append(&mut not_gov_val);
629        }
630
631        let mut eval_namespace = self
632            .evaluator
633            .iter()
634            .filter(|x| x.name == name)
635            .map(|x| x.namespace.clone())
636            .collect::<Vec<Namespace>>();
637        if let Some(mut not_gov_eval) = not_gov_eval {
638            eval_namespace.append(&mut not_gov_eval);
639        }
640
641        let mut creators_val: Vec<String> = vec![];
642        for namespace in val_namespace.clone() {
643            let mut creators = self
644                .creator
645                .iter()
646                .filter(|x| {
647                    let namespace_role = x.namespace.clone();
648                    namespace.is_ancestor_or_equal_of(&namespace_role)
649                })
650                .map(|x| x.name.clone())
651                .collect::<Vec<String>>();
652
653            creators_val.append(&mut creators);
654        }
655
656        let mut creators_eval: Vec<String> = vec![];
657        for namespace in eval_namespace.clone() {
658            let mut creators = self
659                .creator
660                .iter()
661                .filter(|x| {
662                    let namespace_role = x.namespace.clone();
663                    namespace.is_ancestor_or_equal_of(&namespace_role)
664                })
665                .map(|x| x.name.clone())
666                .collect::<Vec<String>>();
667
668            creators_eval.append(&mut creators);
669        }
670
671        let hash_val: Option<HashSet<String>> = if val_namespace.is_empty() {
672            None
673        } else {
674            Some(HashSet::from_iter(creators_val.iter().cloned()))
675        };
676
677        let hash_eval: Option<HashSet<String>> = if eval_namespace.is_empty() {
678            None
679        } else {
680            Some(HashSet::from_iter(creators_eval.iter().cloned()))
681        };
682
683        NameCreators {
684            validation: hash_val,
685            evaluation: hash_eval,
686        }
687    }
688
689    pub const fn issuer_any(&self) -> bool {
690        self.issuer.any
691    }
692
693    pub fn hash_this_rol(
694        &self,
695        role: RoleTypes,
696        namespace: Namespace,
697        name: &str,
698    ) -> bool {
699        match role {
700            RoleTypes::Evaluator => self.evaluator.iter().any(|x| {
701                let namespace_role = x.namespace.clone();
702                namespace_role.is_ancestor_or_equal_of(&namespace)
703                    && x.name == name
704            }),
705            RoleTypes::Validator => self.validator.iter().any(|x| {
706                let namespace_role = x.namespace.clone();
707                namespace_role.is_ancestor_or_equal_of(&namespace)
708                    && x.name == name
709            }),
710            RoleTypes::Witness => self.witness.iter().any(|x| {
711                let namespace_role = x.namespace.clone();
712                namespace_role.is_ancestor_or_equal_of(&namespace)
713                    && x.name == name
714            }),
715            RoleTypes::Creator => self.creator.iter().any(|x| {
716                let namespace_role = x.namespace.clone();
717                namespace_role.is_ancestor_or_equal_of(&namespace)
718                    && x.name == name
719            }),
720            RoleTypes::Issuer => {
721                self.issuer.signers.iter().any(|x| {
722                    let namespace_role = x.namespace.clone();
723                    namespace_role.is_ancestor_or_equal_of(&namespace)
724                        && x.name == name
725                }) || self.issuer.any
726            }
727            RoleTypes::Approver => false,
728        }
729    }
730
731    pub fn role_namespace(
732        &self,
733        role: ProtocolTypes,
734        name: &str,
735    ) -> Vec<Namespace> {
736        let role = RoleTypes::from(role);
737        match role {
738            RoleTypes::Evaluator => self
739                .evaluator
740                .iter()
741                .filter(|x| x.name == name)
742                .map(|x| x.namespace.clone())
743                .collect(),
744            RoleTypes::Validator => self
745                .validator
746                .iter()
747                .filter(|x| x.name == name)
748                .map(|x| x.namespace.clone())
749                .collect(),
750            RoleTypes::Approver => {
751                vec![]
752            }
753            _ => unreachable!("The role is obtained from ProtocolTypes"),
754        }
755    }
756
757    pub fn hash_this_rol_not_namespace(
758        &self,
759        role: ProtocolTypes,
760        name: &str,
761    ) -> bool {
762        let role = RoleTypes::from(role);
763        match role {
764            RoleTypes::Evaluator => {
765                self.evaluator.iter().any(|x| x.name == name)
766            }
767            RoleTypes::Validator => {
768                self.validator.iter().any(|x| x.name == name)
769            }
770            RoleTypes::Approver => false,
771            _ => unreachable!("The role is obtained from ProtocolTypes"),
772        }
773    }
774
775    pub fn max_creations(
776        &self,
777        namespace: Namespace,
778        name: &str,
779    ) -> Option<CreatorQuantity> {
780        self.creator
781            .get(&RoleCreator {
782                name: name.to_string(),
783                namespace,
784                witnesses: BTreeSet::default(),
785                quantity: CreatorQuantity::Infinity,
786            })
787            .map(|x| x.quantity.clone())
788    }
789
790    pub fn get_signers(
791        &self,
792        role: RoleTypes,
793        namespace: Namespace,
794    ) -> (Vec<String>, bool) {
795        match role {
796            RoleTypes::Evaluator => (
797                self.evaluator
798                    .iter()
799                    .filter(|x| {
800                        let namespace_role = x.namespace.clone();
801                        namespace_role.is_ancestor_or_equal_of(&namespace)
802                    })
803                    .map(|x| x.name.clone())
804                    .collect::<Vec<String>>(),
805                false,
806            ),
807            RoleTypes::Validator => (
808                self.validator
809                    .iter()
810                    .filter(|x| {
811                        let namespace_role = x.namespace.clone();
812                        namespace_role.is_ancestor_or_equal_of(&namespace)
813                    })
814                    .map(|x| x.name.clone())
815                    .collect::<Vec<String>>(),
816                false,
817            ),
818            RoleTypes::Witness => (
819                self.witness
820                    .iter()
821                    .filter(|x| {
822                        let namespace_role = x.namespace.clone();
823                        namespace_role.is_ancestor_or_equal_of(&namespace)
824                    })
825                    .map(|x| x.name.clone())
826                    .collect::<Vec<String>>(),
827                false,
828            ),
829            RoleTypes::Creator => (
830                self.creator
831                    .iter()
832                    .filter(|x| {
833                        let namespace_role = x.namespace.clone();
834                        namespace_role.is_ancestor_or_equal_of(&namespace)
835                    })
836                    .map(|x| x.name.clone())
837                    .collect::<Vec<String>>(),
838                false,
839            ),
840            RoleTypes::Issuer => (
841                self.issuer
842                    .signers
843                    .iter()
844                    .filter(|x| {
845                        let namespace_role = x.namespace.clone();
846                        namespace_role.is_ancestor_or_equal_of(&namespace)
847                    })
848                    .map(|x| x.name.clone())
849                    .collect::<Vec<String>>(),
850                self.issuer.any,
851            ),
852            RoleTypes::Approver => (vec![], false),
853        }
854    }
855}
856
857#[derive(Serialize, Deserialize, Clone, Debug)]
858pub enum RoleTypes {
859    Approver,
860    Evaluator,
861    Validator,
862    Witness,
863    Creator,
864    Issuer,
865}
866
867impl From<ProtocolTypes> for RoleTypes {
868    fn from(value: ProtocolTypes) -> Self {
869        match value {
870            ProtocolTypes::Approval => Self::Approver,
871            ProtocolTypes::Evaluation => Self::Evaluator,
872            ProtocolTypes::Validation => Self::Validator,
873        }
874    }
875}
876
877pub enum WitnessesData {
878    Gov,
879    Schema {
880        creator: PublicKey,
881        schema_id: SchemaType,
882        namespace: Namespace,
883    },
884}
885
886impl WitnessesData {
887    pub fn build(
888        schema_id: SchemaType,
889        namespace: Namespace,
890        creator: PublicKey,
891    ) -> Self {
892        if schema_id.is_gov() {
893            Self::Gov
894        } else {
895            Self::Schema {
896                creator,
897                schema_id,
898                namespace,
899            }
900        }
901    }
902}
903
904pub enum HashThisRole {
905    Gov {
906        who: PublicKey,
907        role: RoleTypes,
908    },
909    Schema {
910        who: PublicKey,
911        role: RoleTypes,
912        schema_id: SchemaType,
913        namespace: Namespace,
914    },
915    SchemaWitness {
916        who: PublicKey,
917        creator: PublicKey,
918        schema_id: SchemaType,
919        namespace: Namespace,
920    },
921}
922
923impl HashThisRole {
924    pub fn get_who(&self) -> PublicKey {
925        match self {
926            Self::Gov { who, .. } => who.clone(),
927            Self::Schema { who, .. } => who.clone(),
928            Self::SchemaWitness { who, .. } => who.clone(),
929        }
930    }
931}
932
933#[derive(
934    Debug,
935    Serialize,
936    Deserialize,
937    Clone,
938    PartialEq,
939    Eq,
940    Default,
941    BorshDeserialize,
942    BorshSerialize,
943)]
944pub struct RoleGovIssuer {
945    pub signers: BTreeSet<MemberName>,
946    pub any: bool,
947}
948
949#[derive(
950    Debug,
951    Serialize,
952    Deserialize,
953    Clone,
954    PartialEq,
955    Eq,
956    Default,
957    BorshDeserialize,
958    BorshSerialize,
959)]
960pub struct RoleSchemaIssuer {
961    pub signers: BTreeSet<Role>,
962    pub any: bool,
963}
964
965/// Governance policy.
966#[derive(
967    Debug,
968    Serialize,
969    Deserialize,
970    Clone,
971    PartialEq,
972    Eq,
973    Default,
974    BorshDeserialize,
975    BorshSerialize,
976)]
977pub struct PolicyGov {
978    /// Approve quorum
979    pub approve: Quorum,
980    /// Evaluate quorum
981    pub evaluate: Quorum,
982    /// Validate quorum
983    pub validate: Quorum,
984}
985
986impl PolicyGov {
987    pub fn get_quorum(&self, role: ProtocolTypes) -> Option<Quorum> {
988        match role {
989            ProtocolTypes::Approval => Some(self.approve.clone()),
990            ProtocolTypes::Evaluation => Some(self.evaluate.clone()),
991            ProtocolTypes::Validation => Some(self.validate.clone()),
992        }
993    }
994}
995
996#[derive(
997    Debug,
998    Serialize,
999    Deserialize,
1000    Clone,
1001    Hash,
1002    PartialEq,
1003    Eq,
1004    Default,
1005    BorshDeserialize,
1006    BorshSerialize,
1007)]
1008pub struct PolicySchema {
1009    /// Evaluate quorum
1010    pub evaluate: Quorum,
1011    /// Validate quorum
1012    pub validate: Quorum,
1013}
1014
1015impl PolicySchema {
1016    pub fn get_quorum(&self, role: ProtocolTypes) -> Option<Quorum> {
1017        match role {
1018            ProtocolTypes::Approval => None,
1019            ProtocolTypes::Evaluation => Some(self.evaluate.clone()),
1020            ProtocolTypes::Validation => Some(self.validate.clone()),
1021        }
1022    }
1023}
ave_core/governance/model.rs

ave_core/governance/
model.rs
