hbkr-rs 0.3.2

Hashblock Key Rotation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

//! HBKR Said Event

use crate::{
    dummy_event::DummyEventMessage,
    errors::KrError,
    event_message::EventMessage,
    said::{SelfAddressing, SelfAddressingPrefix},
    serialization_info::SerializationFormats,
    Digestible, EventTypeTag, Typeable,
};

use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SaidEvent<D> {
    #[serde(rename = "d", skip_serializing)]
    digest: SelfAddressingPrefix,

    #[serde(flatten)]
    pub content: D,
}

impl<D: Serialize + Clone + Typeable> SaidEvent<D> {
    pub fn new(digest: SelfAddressingPrefix, content: D) -> Self {
        Self { digest, content }
    }
    pub(crate) fn to_message(
        event: D,
        format: SerializationFormats,
        derivation: &SelfAddressing,
    ) -> Result<EventMessage<SaidEvent<D>>, KrError> {
        let dummy_event = DummyEventMessage::dummy_event(event.clone(), format, derivation)?;
        let digest = derivation.derive(&dummy_event.serialize()?);

        Ok(EventMessage {
            serialization_info: dummy_event.serialization_info,
            event: Self {
                digest,
                content: event,
            },
        })
    }
}

impl<D> Digestible for SaidEvent<D> {
    fn get_digest(&self) -> SelfAddressingPrefix {
        self.digest.clone()
    }
}

impl<D: Typeable> Typeable for SaidEvent<D> {
    fn get_type(&self) -> EventTypeTag {
        self.content.get_type()
    }
}