guardian-shared 0.13.2

Shared types and utilities for Guardian
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

use crate::auth_request_payload::AuthRequestPayload;
use miden_protocol::account::AccountId;
use miden_protocol::crypto::hash::rpo::Rpo256;
use miden_protocol::{Felt, Word};
use serde::Serialize;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AuthRequestMessage {
    account_id: AccountId,
    timestamp: i64,
    payload: AuthRequestPayload,
}

impl AuthRequestMessage {
    pub fn new(account_id: AccountId, timestamp: i64, payload: AuthRequestPayload) -> Self {
        Self {
            account_id,
            timestamp,
            payload,
        }
    }

    pub fn from_account_id_hex(
        account_id_hex: &str,
        timestamp: i64,
        payload: AuthRequestPayload,
    ) -> Result<Self, String> {
        let account_id = AccountId::from_hex(account_id_hex)
            .map_err(|e| format!("Invalid account ID hex: {e}"))?;
        Ok(Self::new(account_id, timestamp, payload))
    }

    pub fn from_protobuf_message<T: prost::Message>(
        account_id: AccountId,
        timestamp: i64,
        request: &T,
    ) -> Self {
        Self::new(
            account_id,
            timestamp,
            AuthRequestPayload::from_protobuf_message(request),
        )
    }

    pub fn from_json_serializable<T: Serialize>(
        account_id: AccountId,
        timestamp: i64,
        request: &T,
    ) -> Result<Self, String> {
        let payload = AuthRequestPayload::from_json_serializable(request)?;
        Ok(Self::new(account_id, timestamp, payload))
    }

    pub fn to_word(&self) -> Word {
        let account_id_felts: [Felt; 2] = self.account_id.into();
        let timestamp_felt = Felt::new(self.timestamp as u64);
        let payload_elements = self.payload.as_elements();
        let message_elements = vec![
            account_id_felts[0],
            account_id_felts[1],
            timestamp_felt,
            payload_elements[0],
            payload_elements[1],
            payload_elements[2],
            payload_elements[3],
        ];
        Rpo256::hash_elements(&message_elements)
    }
}

#[cfg(test)]
mod tests {
    use super::AuthRequestMessage;
    use crate::auth_request_payload::AuthRequestPayload;
    use miden_protocol::account::AccountId;

    #[test]
    fn request_message_digest_changes_with_payload() {
        let account_id =
            AccountId::from_hex("0x8a65fc5a39e4cd106d648e3eb4ab5f").expect("account id");
        let timestamp = 1_700_000_000i64;
        let left_payload =
            AuthRequestPayload::from_json_bytes(br#"{"op":"get_state"}"#).expect("left payload");
        let right_payload =
            AuthRequestPayload::from_json_bytes(br#"{"op":"push_delta"}"#).expect("right payload");

        let left = AuthRequestMessage::new(account_id, timestamp, left_payload).to_word();
        let right = AuthRequestMessage::new(account_id, timestamp, right_payload).to_word();

        assert_ne!(left, right);
    }
}