blueprint-networking 0.2.0-alpha.2

Networking utilities for Tangle Blueprints
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

mod behaviour;
mod handler;

pub use behaviour::{BlueprintProtocolBehaviour, BlueprintProtocolEvent};
use blueprint_crypto::KeyType;
use libp2p::PeerId;

use crate::discovery::peers::VerificationIdentifierKey;
use serde::{Deserialize, Serialize};

/// A message sent to a specific instance or broadcast to all instances
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(bound = "K: KeyType")]
pub enum InstanceMessageRequest<K: KeyType> {
    /// Handshake request with authentication
    Handshake {
        /// Public key for authentication
        verification_id_key: VerificationIdentifierKey<K>,
        /// Signature for verification
        signature: K::Signature,
        /// Handshake message
        msg: HandshakeMessage,
    },
    /// Protocol-specific message with custom payload
    Protocol {
        /// Protocol identifier (e.g., "consensus/1.0.0", "sync/1.0.0")
        protocol: String,
        /// Protocol-specific message payload
        payload: Vec<u8>,
        /// Optional metadata for the protocol handler
        metadata: Option<Vec<u8>>,
    },
}

/// Response to an instance message
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(bound = "K: KeyType")]
pub enum InstanceMessageResponse<K: KeyType> {
    /// Handshake response with authentication
    Handshake {
        /// Public key for authentication
        verification_id_key: VerificationIdentifierKey<K>,
        /// Signature for verification
        signature: K::Signature,
        /// Handshake message
        msg: HandshakeMessage,
    },
    /// Success response with optional data
    Success {
        /// Protocol identifier (e.g., "consensus/1.0.0", "sync/1.0.0")
        protocol: String,
        /// Response data specific to the protocol
        data: Option<Vec<u8>>,
    },
    /// Error response with details
    Error {
        /// Error code
        code: u16,
        /// Error message
        message: String,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HandshakeMessage {
    /// Sender [`PeerId`]
    pub sender: PeerId,
    /// A Unix timestamp in milliseconds
    pub timestamp: u128,
}

impl HandshakeMessage {
    /// Maximum age for a handshake message in milliseconds
    pub const MAX_AGE: u128 = 30_000;

    /// Creates a new handshake message
    ///
    /// # Panics
    /// - If the system time is before the Unix epoch
    #[must_use]
    pub fn new(sender: PeerId) -> Self {
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .expect("time went backwards")
            .as_millis();
        Self { sender, timestamp }
    }

    /// Checks if the handshake message is expired
    ///
    /// # Arguments
    /// - `max_age`: Maximum age in milliseconds
    ///
    /// # Returns
    /// - `true` if the message is expired, `false` otherwise
    ///
    /// # Panics
    /// - If the system time is before the Unix epoch
    #[must_use]
    pub fn is_expired(&self, max_age: u128) -> bool {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .expect("time went backwards")
            .as_millis();
        now.saturating_sub(self.timestamp) > max_age
    }

    /// Converts the handshake message to a byte array
    #[must_use]
    pub fn to_bytes(&self, other_peer_id: &PeerId) -> Vec<u8> {
        let mut bytes = Vec::new();
        bytes.extend(&self.sender.to_bytes());
        bytes.extend(other_peer_id.to_bytes());
        bytes.extend(&self.timestamp.to_be_bytes());
        bytes
    }
}