use std::fmt;
use serde::{Deserialize, Serialize};
pub const ALPN: &[u8] = b"/federation-net/1";
pub const PROTOCOL_VERSION: u16 = 1;
pub(crate) const MAX_HANDSHAKE_FRAME_SIZE: usize = 16 * 1024;
fn hash_with_domain(domain: &str, name: &str) -> [u8; 32] {
let mut hasher = blake3::Hasher::new();
hasher.update(domain.as_bytes());
hasher.update(name.as_bytes());
*hasher.finalize().as_bytes()
}
fn fmt_id(bytes: &[u8; 32], f: &mut fmt::Formatter<'_>) -> fmt::Result {
for byte in bytes {
write!(f, "{byte:02x}")?;
}
Ok(())
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub struct NetworkId([u8; 32]);
impl NetworkId {
pub fn from_bytes(bytes: [u8; 32]) -> Self {
Self(bytes)
}
pub fn from_name(name: &str) -> Self {
Self(hash_with_domain("federation-net:network:", name))
}
pub fn as_bytes(&self) -> &[u8; 32] {
&self.0
}
}
impl fmt::Display for NetworkId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt_id(&self.0, f)
}
}
impl fmt::Debug for NetworkId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "NetworkId(")?;
fmt_id(&self.0, f)?;
write!(f, ")")
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub struct SchemaId([u8; 32]);
impl SchemaId {
pub fn from_bytes(bytes: [u8; 32]) -> Self {
Self(bytes)
}
pub fn from_name(name: &str) -> Self {
Self(hash_with_domain("federation-net:schema:", name))
}
pub fn as_bytes(&self) -> &[u8; 32] {
&self.0
}
}
impl fmt::Display for SchemaId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt_id(&self.0, f)
}
}
impl fmt::Debug for SchemaId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "SchemaId(")?;
fmt_id(&self.0, f)?;
write!(f, ")")
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) struct Handshake {
pub protocol_version: u16,
pub network_id: NetworkId,
pub schema_id: SchemaId,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) struct HandshakeAck {
pub accepted: bool,
pub error: Option<HandshakeErrorCode>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub(crate) enum HandshakeErrorCode {
UnsupportedProtocolVersion,
NetworkMismatch,
SchemaMismatch,
InvalidHandshake,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) struct MessageRequest {
pub request_id: [u8; 16],
pub payload: Vec<u8>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub(crate) enum MessageRejectReason {
MalformedPayload,
ShuttingDown,
Overloaded,
}
impl fmt::Display for MessageRejectReason {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::MalformedPayload => write!(f, "malformed payload"),
Self::ShuttingDown => write!(f, "peer is shutting down"),
Self::Overloaded => write!(f, "peer is overloaded"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) enum MessageResponse {
Accepted {
request_id: [u8; 16],
},
Rejected {
request_id: [u8; 16],
reason: MessageRejectReason,
},
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn network_id_from_name_is_deterministic() {
let a = NetworkId::from_name("example-network");
let b = NetworkId::from_name("example-network");
assert_eq!(a, b);
}
#[test]
fn different_network_names_produce_different_ids() {
let a = NetworkId::from_name("network-a");
let b = NetworkId::from_name("network-b");
assert_ne!(a, b);
}
#[test]
fn schema_id_from_name_is_deterministic() {
let a = SchemaId::from_name("demo-message-v1");
let b = SchemaId::from_name("demo-message-v1");
assert_eq!(a, b);
assert_ne!(a, SchemaId::from_name("demo-message-v2"));
}
#[test]
fn network_and_schema_domains_are_separated() {
let network = NetworkId::from_name("same-name");
let schema = SchemaId::from_name("same-name");
assert_ne!(network.as_bytes(), schema.as_bytes());
}
}