keri_core/event/
mod.rs

1use crate::event_message::msg::KeriEvent;
2use crate::event_message::{EventTypeTag, Typeable};
3use crate::prefix::IdentifierPrefix;
4use crate::state::IdentifierState;
5use said::derivation::HashFunction;
6use said::version::format::SerializationFormats;
7use serde::{Deserialize, Serialize};
8pub mod event_data;
9pub mod receipt;
10pub mod sections;
11use self::event_data::EventData;
12use crate::error::Error;
13use crate::state::EventSemantics;
14use serde_hex::{Compact, SerHex};
15
16#[derive(
17    Serialize,
18    Deserialize,
19    Debug,
20    Clone,
21    PartialEq,
22    rkyv::Archive,
23    rkyv::Serialize,
24    rkyv::Deserialize,
25)]
26#[rkyv(derive(Debug))]
27pub struct KeyEvent {
28    #[serde(rename = "i")]
29    pub prefix: IdentifierPrefix,
30
31    #[serde(rename = "s", with = "SerHex::<Compact>")]
32    pub sn: u64,
33
34    #[serde(flatten)]
35    pub event_data: EventData,
36}
37
38impl KeyEvent {
39    pub fn new(prefix: IdentifierPrefix, sn: u64, event_data: EventData) -> Self {
40        KeyEvent {
41            prefix,
42            sn,
43            event_data,
44        }
45    }
46
47    pub fn to_message(
48        self,
49        format: SerializationFormats,
50        derivation: HashFunction,
51    ) -> Result<KeriEvent<KeyEvent>, Error> {
52        match (&self.prefix, self.event_data.clone()) {
53            (IdentifierPrefix::SelfAddressing(_), EventData::Icp(icp)) => {
54                icp.incept_self_addressing(derivation.clone(), format)
55            }
56            (IdentifierPrefix::SelfAddressing(_), EventData::Dip(dip)) => {
57                dip.incept_self_addressing(derivation.clone(), format)
58            }
59            _ => Ok(KeriEvent::new(format, derivation, self)),
60        }
61    }
62}
63
64impl Typeable for KeyEvent {
65    type TypeTag = EventTypeTag;
66    fn get_type(&self) -> EventTypeTag {
67        self.event_data.get_type()
68    }
69}
70
71impl EventSemantics for KeyEvent {
72    fn apply_to(&self, state: IdentifierState) -> Result<IdentifierState, Error> {
73        match self.event_data {
74            EventData::Icp(_) | EventData::Dip(_) => {
75                // ICP events require the state to be uninitialized
76                if state.prefix != IdentifierPrefix::default() {
77                    return Err(Error::EventDuplicateError);
78                }
79                if self.sn != 0 {
80                    return Err(Error::SemanticError("SN is not correct".to_string()));
81                }
82            }
83            _ => {
84                // prefix must equal.
85                if self.prefix != state.prefix {
86                    return Err(Error::SemanticError("Prefix does not match".to_string()));
87                // sn must be incremented
88                // TODO recovery will break this rule when we implement it
89                } else if self.sn < state.sn + 1 {
90                    return Err(Error::EventDuplicateError);
91                } else if self.sn > state.sn + 1 {
92                    return Err(Error::EventOutOfOrderError);
93                }
94            }
95        };
96        self.event_data.apply_to(IdentifierState {
97            sn: self.sn,
98            prefix: self.prefix.clone(),
99            ..state
100        })
101    }
102}
103
104#[cfg(test)]
105mod tests {
106    use super::*;
107    use serde_json;
108
109    #[test]
110    fn ser_der() -> Result<(), serde_json::Error> {
111        let event_str = "{
112  \"i\": \"DXq5YqaL6L48pf0fu7IUhL0JRaU2_RxFP0AL43wYn148\",
113  \"s\": \"0\",
114  \"t\": \"icp\",
115  \"kt\": \"2\",
116  \"k\":
117  [
118    \"BWoNZsa88VrTkep6HQt27fTh-4HA8tr54sHON1vWl6FE\",
119    \"B8tr54sHON1vWVrTkep6H-4HAl6FEQt27fThWoNZsa88\",
120    \"BVrTkep6HHA8tr54sHON1Qt27fThWoNZsa88-4vWl6FE\"
121  ],
122  \"nt\": \"3\",
123  \"n\" : 
124    [
125      \"ETNZH3ULvYawyZ-i0d8JZU6JR2nmAoAfSVPzhzS6b5CM\",
126      \"EnmwyZdi0d8JZAoTNZYAfSVPzhzaU6JR2H3ULvS6b5CM\",
127      \"ETNZH3ULvS6bYAfSVPzhzaU6JR2nmwyZfi0d8JZ5s8bk\"
128    ],
129  \"bt\": \"2\",
130  \"b\":
131  [
132    \"DVrTkep6H-Qt27fThWoNZsa884HA8tr54sHON1vWl6FE\",
133    \"DHON1vWl6FEQt27fThWoNZsa88VrTkep6H-4HA8tr54s\",
134    \"DThWoNZsa88VrTkeQt27fp6H-4HA8tr54sHON1vWl6FE\"
135  ],
136  \"c\": [],
137  \"a\": []
138}";
139
140        let event: KeyEvent = serde_json::from_str(event_str)?;
141
142        print!("\n{}\n", serde_json::to_string(&event)?);
143
144        Ok(())
145    }
146}