ave_core/evaluation/
request.rs

1use crate::{
2    evaluation::{response::EvaluatorError, runner::types::EvaluateInfo},
3    governance::data::GovernanceData,
4};
5use ave_common::{
6    Namespace, SchemaType, ValueWrapper,
7    identity::{DigestIdentifier, PublicKey, Signed},
8    request::EventRequest,
9};
10
11use borsh::{BorshDeserialize, BorshSerialize};
12use serde::{Deserialize, Serialize};
13
14/// A struct representing an evaluation request.
15#[derive(
16    Debug, Clone, Serialize, Deserialize, BorshSerialize, BorshDeserialize,
17)]
18pub struct EvaluationReq {
19    /// The signed event request.
20    pub event_request: Signed<EventRequest>,
21
22    pub governance_id: DigestIdentifier,
23
24    pub data: EvaluateData,
25
26    pub sn: u64,
27
28    pub gov_version: u64,
29
30    pub namespace: Namespace,
31
32    pub schema_id: SchemaType,
33
34    pub signer: PublicKey,
35
36    pub signer_is_owner: bool,
37}
38
39impl EvaluationReq {
40    pub fn build_evaluate_info(
41        &self,
42        init_state: &Option<ValueWrapper>,
43    ) -> Result<EvaluateInfo, EvaluatorError> {
44        match (self.event_request.content(), &self.data) {
45            (
46                EventRequest::Fact(fact_request),
47                EvaluateData::GovFact { state },
48            ) => Ok(EvaluateInfo::GovFact {
49                payload: fact_request.payload.clone(),
50                state: state.clone(),
51            }),
52            (
53                EventRequest::Fact(fact_request),
54                EvaluateData::TrackerSchemasFact { contract, state },
55            ) => init_state.as_ref().map_or_else(
56                || {
57                    Err(EvaluatorError::InternalError(
58                        "Init state must be some".to_owned(),
59                    ))
60                },
61                |init_state| {
62                    Ok(EvaluateInfo::TrackerSchemasFact {
63                        contract: contract.clone(),
64                        init_state: init_state.clone(),
65                        state: state.clone(),
66                        payload: fact_request.payload.clone(),
67                    })
68                },
69            ),
70            (
71                EventRequest::Transfer(transfer_request),
72                EvaluateData::GovTransfer { state },
73            ) => Ok(EvaluateInfo::GovTransfer {
74                new_owner: transfer_request.new_owner.clone(),
75                state: state.clone(),
76            }),
77            (
78                EventRequest::Transfer(transfer_request),
79                EvaluateData::TrackerSchemasTransfer {
80                    governance_data,
81                    namespace,
82                    schema_id,
83                    ..
84                },
85            ) => Ok(EvaluateInfo::TrackerSchemasTransfer {
86                governance_data: governance_data.clone(),
87                new_owner: transfer_request.new_owner.clone(),
88                old_owner: self.event_request.signature().signer.clone(),
89                namespace: namespace.clone(),
90                schema_id: schema_id.clone(),
91            }),
92            (
93                EventRequest::Confirm(confirm_request),
94                EvaluateData::GovConfirm { state },
95            ) => Ok(EvaluateInfo::GovConfirm {
96                new_owner: self.event_request.signature().signer.clone(),
97                old_owner_name: confirm_request.name_old_owner.clone(),
98                state: state.clone(),
99            }),
100            _ => Err(EvaluatorError::InvalidEventRequest(
101                "Evaluate data does not correspond to the type of request"
102                    .to_string(),
103            )),
104        }
105    }
106}
107
108#[derive(
109    Debug, Clone, Serialize, Deserialize, BorshSerialize, BorshDeserialize,
110)]
111pub enum EvaluateData {
112    GovFact {
113        state: GovernanceData,
114    },
115    GovTransfer {
116        state: GovernanceData,
117    },
118    GovConfirm {
119        state: GovernanceData,
120    },
121    TrackerSchemasFact {
122        contract: String,
123        state: ValueWrapper,
124    },
125    TrackerSchemasTransfer {
126        state: ValueWrapper,
127        governance_data: GovernanceData,
128        namespace: Namespace,
129        schema_id: SchemaType,
130    },
131}
132
133impl EvaluateData {
134    pub const fn is_gov_event(&self) -> bool {
135        match self {
136            Self::GovFact { .. }
137            | Self::GovTransfer { .. }
138            | Self::GovConfirm { .. } => true,
139            Self::TrackerSchemasFact { .. }
140            | Self::TrackerSchemasTransfer { .. } => false,
141        }
142    }
143}
144
145/// A struct representing the context in which the evaluation is being performed.
146#[derive(
147    Debug,
148    Clone,
149    Serialize,
150    Deserialize,
151    Eq,
152    PartialEq,
153    BorshSerialize,
154    BorshDeserialize,
155)]
156pub struct SubjectContext {
157    pub subject_id: DigestIdentifier,
158    pub governance_id: DigestIdentifier,
159    pub schema_id: SchemaType,
160    pub is_owner: bool,
161    pub namespace: Namespace,
162}
ave_core/evaluation/request.rs

ave_core/evaluation/
request.rs
