teliox 0.17.13

Library for the Transaction Event Log
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use std::sync::Arc;

use keri_core::{database::EventDatabase, processor::event_storage::EventStorage};

use crate::{
    database::TelEventDatabase,
    error::Error,
    event::{verifiable_event::VerifiableEvent, Event},
    query::SignedTelQuery,
};

use self::{
    notification::{TelNotification, TelNotificationBus, TelNotificationKind, TelNotifier},
    storage::TelEventStorage,
    validator::TelEventValidator,
};

pub mod escrow;
pub mod notification;
pub mod storage;
pub mod validator;

pub struct TelEventProcessor<D: TelEventDatabase, K: EventDatabase> {
    kel_reference: Arc<EventStorage<K>>,
    pub tel_reference: Arc<TelEventStorage<D>>,
    pub publisher: TelNotificationBus,
}

impl<D: TelEventDatabase, K: EventDatabase> TelEventProcessor<D, K> {
    pub fn new(
        kel_reference: Arc<EventStorage<K>>,
        tel_reference: Arc<TelEventStorage<D>>,
        tel_publisher: Option<TelNotificationBus>,
    ) -> Self {
        Self {
            kel_reference,
            tel_reference,
            publisher: tel_publisher.unwrap_or_default(),
        }
    }

    pub fn register_observer(
        &mut self,
        observer: Arc<dyn TelNotifier + Send + Sync>,
        notifications: Vec<TelNotificationKind>,
    ) -> Result<(), Error> {
        self.publisher.register_observer(observer, notifications)?;
        Ok(())
    }

    // Checks verifiable event and adds it to database.
    pub fn process(&self, event: VerifiableEvent) -> Result<(), Error> {
        let validator =
            TelEventValidator::new(self.tel_reference.clone(), self.kel_reference.clone());
        match &event.event.clone() {
            Event::Management(ref man) => match validator.validate_management(man, &event.seal) {
                Ok(_) => {
                    self.tel_reference
                        .db
                        .add_new_event(event.clone(), &man.data.prefix)
                        .unwrap();
                    self.publisher
                        .notify(&TelNotification::TelEventAdded(event))?;
                    Ok(())
                }
                Err(e) => match e {
                    Error::OutOfOrderError => {
                        self.publisher.notify(&TelNotification::OutOfOrder(event))
                    }
                    Error::MissingIssuerEventError => self
                        .publisher
                        .notify(&TelNotification::MissingIssuer(event)),
                    Error::MissingRegistryError => self
                        .publisher
                        .notify(&TelNotification::MissingRegistry(event)),
                    Error::EventAlreadySavedError => {
                        // Means that vc of given registry is already accepted
                        Ok(())
                    }
                    e => Err(e),
                },
            },
            Event::Vc(ref vc_ev) => {
                match validator.validate_vc(vc_ev, &event.seal) {
                    Ok(_) => {
                        self.tel_reference
                            .db
                            .add_new_event(event.clone(), &vc_ev.data.data.prefix)
                            .unwrap();
                        self.publisher
                            .notify(&TelNotification::TelEventAdded(event))
                    }
                    Err(Error::MissingIssuerEventError) => self
                        .publisher
                        .notify(&TelNotification::MissingIssuer(event)),
                    Err(Error::MissingRegistryError) => self
                        .publisher
                        .notify(&TelNotification::MissingRegistry(event)),
                    Err(Error::OutOfOrderError) => {
                        self.publisher.notify(&TelNotification::OutOfOrder(event))
                    }
                    Err(Error::EventAlreadySavedError) => {
                        // Means that vc of given id is already accepted
                        Ok(())
                    }
                    Err(e) => Err(e),
                }
            }
        }
    }

    pub fn process_signed_query(&self, qr: SignedTelQuery) -> Result<TelReplyType, Error> {
        let signature = qr.signature;
        // check signatures
        let ver_result = signature.verify(&(qr.query.encode()?), &self.kel_reference)?;

        if !ver_result {
            return Err(Error::Generic("Wrong query event signature".to_string()));
        };

        // unpack and check what's inside
        self.tel_reference.process_query(&qr.query.data.data)
    }
}

pub enum TelReplyType {
    Tel(Vec<u8>),
}

impl ToString for TelReplyType {
    fn to_string(&self) -> String {
        match self {
            TelReplyType::Tel(tel) => String::from_utf8(tel.to_vec()).unwrap(),
        }
    }
}