enigma-node-types 0.0.1

Canonical node-facing types and strict codecs for Enigma (UserId hashing, identities, presence, relay envelopes).
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

use std::convert::TryFrom;

use serde::{Deserialize, Serialize};

use crate::error::{EnigmaNodeTypesError, Result};
use crate::user_id::{normalize_username, UserId};

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct PublicIdentity {
    pub user_id: UserId,
    pub username_hint: Option<String>,
    pub signing_public_key: Vec<u8>,
    pub encryption_public_key: Vec<u8>,
    pub signature: Vec<u8>,
    pub created_at_ms: u64,
}

impl PublicIdentity {
    pub fn validate(&self) -> Result<()> {
        if self.signing_public_key.is_empty() {
            return Err(EnigmaNodeTypesError::InvalidField("signing_public_key"));
        }
        if self.encryption_public_key.is_empty() {
            return Err(EnigmaNodeTypesError::InvalidField("encryption_public_key"));
        }
        if self.signature.is_empty() {
            return Err(EnigmaNodeTypesError::InvalidField("signature"));
        }
        if self.created_at_ms == 0 {
            return Err(EnigmaNodeTypesError::InvalidField("created_at_ms"));
        }
        if let Some(hint) = &self.username_hint {
            normalize_username(hint)?;
        }
        Ok(())
    }
}

pub fn signed_payload(
    username_hint: &str,
    signing_public_key: &[u8],
    encryption_public_key: &[u8],
) -> Vec<u8> {
    let hint_bytes = username_hint.as_bytes();
    let hint_len = match u32::try_from(hint_bytes.len()) {
        Ok(v) => v,
        Err(_) => u32::MAX,
    };
    let signing_len = match u32::try_from(signing_public_key.len()) {
        Ok(v) => v,
        Err(_) => u32::MAX,
    };
    let encryption_len = match u32::try_from(encryption_public_key.len()) {
        Ok(v) => v,
        Err(_) => u32::MAX,
    };
    let mut payload = Vec::with_capacity(
        hint_bytes.len()
            .saturating_add(signing_public_key.len())
            .saturating_add(encryption_public_key.len())
            .saturating_add(12),
    );
    payload.extend_from_slice(&hint_len.to_be_bytes());
    payload.extend_from_slice(hint_bytes);
    payload.extend_from_slice(&signing_len.to_be_bytes());
    payload.extend_from_slice(signing_public_key);
    payload.extend_from_slice(&encryption_len.to_be_bytes());
    payload.extend_from_slice(encryption_public_key);
    payload
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct RegisterRequest {
    pub identity: PublicIdentity,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct RegisterResponse {
    pub ok: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct ResolveResponse {
    pub identity: Option<PublicIdentity>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct CheckUserResponse {
    pub exists: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct SyncRequest {
    pub identities: Vec<PublicIdentity>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct SyncResponse {
    pub merged: usize,
}