use ark_ff::Field;
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use std::net::SocketAddr;
use thiserror::Error;
#[derive(Error, Debug, PartialEq)]
pub enum NetworkError {
#[error("The message was not sent correctly")]
SendError,
#[error("timeout reached.")]
Timeout,
#[error("the party with ID {0:?} is not in the network")]
PartyNotFound(PartyId),
#[error("the client with ID {0:?} is not connected")]
ClientNotFound(ClientId),
}
#[derive(Error, Debug, Clone, PartialEq)]
pub enum ConsensusError {
#[error("Node list mismatch from node at {node_address}")]
NodeListMismatch { node_address: SocketAddr },
#[error("Client list digest mismatch from party {party_id}")]
ClientListDigestMismatch { party_id: PartyId },
#[error("Timed out waiting for {expected} clients, only {connected} connected")]
ClientReadinessTimeout { expected: usize, connected: usize },
#[error("Timed out waiting for consensus from {missing_count} nodes")]
ConsensusTimeout { missing_count: usize },
#[error("Consensus query failed: {0}")]
QueryFailed(String),
#[error("Consensus aborted: {0}")]
Aborted(String),
}
#[derive(Clone, Debug, PartialEq)]
pub enum ConsensusGate {
NotRequired,
Pending,
Ready,
Failed(String),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VerifiedOrdering {
node_keys: Vec<NodePublicKey>,
client_keys: Vec<NodePublicKey>,
}
impl VerifiedOrdering {
pub fn new(node_keys: Vec<NodePublicKey>, client_keys: Vec<NodePublicKey>) -> Self {
Self {
node_keys,
client_keys,
}
}
pub fn node_count(&self) -> usize {
self.node_keys.len()
}
pub fn client_count(&self) -> usize {
self.client_keys.len()
}
pub fn party_id_for_node(&self, pk: &NodePublicKey) -> Option<PartyId> {
self.node_keys.iter().position(|k| k == pk)
}
pub fn client_id_for_client(&self, pk: &NodePublicKey) -> Option<ClientId> {
self.client_keys.iter().position(|k| k == pk)
}
pub fn node_key(&self, party_id: PartyId) -> Option<&NodePublicKey> {
self.node_keys.get(party_id)
}
pub fn client_key(&self, client_id: ClientId) -> Option<&NodePublicKey> {
self.client_keys.get(client_id)
}
pub fn node_keys(&self) -> &[NodePublicKey] {
&self.node_keys
}
pub fn client_keys(&self) -> &[NodePublicKey] {
&self.client_keys
}
}
pub type PartyId = usize;
pub type ClientId = usize;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct CertificateIdentity([u8; 32]);
impl CertificateIdentity {
pub const fn from_bytes(bytes: [u8; 32]) -> Self {
Self(bytes)
}
pub const fn into_bytes(self) -> [u8; 32] {
self.0
}
pub const fn as_bytes(&self) -> &[u8; 32] {
&self.0
}
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct NodePublicKey(pub Vec<u8>);
impl NodePublicKey {
pub fn certificate_identity(&self) -> CertificateIdentity {
let mut hasher =
blake3::Hasher::new_derive_key("stoffel-network-certificate-spki-identity-v1");
hasher.update(&self.0);
CertificateIdentity::from_bytes(*hasher.finalize().as_bytes())
}
pub fn derive_id(&self) -> usize {
let mut hasher =
blake3::Hasher::new_derive_key("stoffel-network-legacy-spki-bookkeeping-id-v2");
hasher.update(&self.0);
let mut bytes = [0u8; 8];
bytes.copy_from_slice(&hasher.finalize().as_bytes()[..8]);
u64::from_le_bytes(bytes) as usize
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ClientType {
Server,
Client,
}
pub type Timeout = usize;
pub trait Message: Serialize + for<'a> Deserialize<'a> + Sized {
fn sender_id(&self) -> PartyId;
fn bytes(&self) -> &[u8];
}
#[async_trait]
pub trait Network {
type NodeType: Node;
type NetworkConfig;
async fn send(&self, recipient: PartyId, message: &[u8]) -> Result<usize, NetworkError>;
async fn broadcast(&self, message: &[u8]) -> Result<usize, NetworkError>;
fn parties(&self) -> Vec<&Self::NodeType>;
fn parties_mut(&mut self) -> Vec<&mut Self::NodeType>;
fn config(&self) -> &Self::NetworkConfig;
fn node(&self, id: PartyId) -> Option<&Self::NodeType>;
fn node_mut(&mut self, id: PartyId) -> Option<&mut Self::NodeType>;
async fn send_to_client(&self, client: ClientId, message: &[u8])
-> Result<usize, NetworkError>;
fn clients(&self) -> Vec<ClientId>;
fn is_client_connected(&self, client: ClientId) -> bool;
fn local_party_id(&self) -> PartyId;
fn party_count(&self) -> usize;
fn verified_ordering(&self) -> Option<VerifiedOrdering>;
}
pub trait Node: Send + Sync {
fn id(&self) -> PartyId;
fn scalar_id<F: Field>(&self) -> F;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_node_public_key_derive_id_consistency() {
let key = NodePublicKey(vec![1, 2, 3, 4, 5]);
let id_first = key.derive_id();
let id_second = key.derive_id();
assert_eq!(
id_first, id_second,
"derive_id must return the same value for the same key bytes"
);
}
#[test]
fn test_node_public_key_derive_id_different() {
let key_a = NodePublicKey(vec![1, 2, 3]);
let key_b = NodePublicKey(vec![4, 5, 6]);
assert_ne!(
key_a.derive_id(),
key_b.derive_id(),
"derive_id should return different values for different key bytes"
);
}
#[test]
fn test_certificate_identity_is_full_width_deterministic_and_distinct() {
let key_a = NodePublicKey(vec![1, 2, 3]);
let key_b = NodePublicKey(vec![1, 2, 4]);
let first = key_a.certificate_identity();
assert_eq!(first, key_a.certificate_identity());
assert_ne!(first, key_b.certificate_identity());
assert_eq!(first.as_bytes().len(), 32);
assert_eq!(CertificateIdentity::from_bytes(first.into_bytes()), first);
}
#[test]
fn test_network_error_display_non_empty() {
let variants: Vec<NetworkError> = vec![
NetworkError::SendError,
NetworkError::Timeout,
NetworkError::PartyNotFound(42),
NetworkError::ClientNotFound(99),
];
for error in &variants {
let display = format!("{}", error);
assert!(
!display.is_empty(),
"Display output for {:?} must not be empty",
error
);
}
}
#[test]
fn test_client_type_variants_distinct() {
let server = ClientType::Server;
let client = ClientType::Client;
assert!(
matches!(server, ClientType::Server),
"server variant should match ClientType::Server"
);
assert!(
!matches!(server, ClientType::Client),
"server variant should not match ClientType::Client"
);
assert!(
matches!(client, ClientType::Client),
"client variant should match ClientType::Client"
);
assert!(
!matches!(client, ClientType::Server),
"client variant should not match ClientType::Server"
);
}
#[test]
fn test_node_public_key_derive_id_empty() {
let key = NodePublicKey(vec![]);
let id_first = key.derive_id();
let id_second = key.derive_id();
assert_eq!(
id_first, id_second,
"derive_id on empty bytes must be deterministic"
);
}
#[test]
fn test_consensus_error_display() {
let addr: SocketAddr = "127.0.0.1:5000".parse().unwrap();
let errors = vec![
ConsensusError::NodeListMismatch { node_address: addr },
ConsensusError::ClientListDigestMismatch { party_id: 2 },
ConsensusError::ClientReadinessTimeout {
expected: 3,
connected: 1,
},
ConsensusError::ConsensusTimeout { missing_count: 2 },
ConsensusError::QueryFailed("test".into()),
ConsensusError::Aborted("test".into()),
];
for error in &errors {
let display = format!("{}", error);
assert!(!display.is_empty());
}
}
#[test]
fn test_consensus_gate_variants() {
assert_eq!(ConsensusGate::NotRequired, ConsensusGate::NotRequired);
assert_eq!(ConsensusGate::Pending, ConsensusGate::Pending);
assert_eq!(ConsensusGate::Ready, ConsensusGate::Ready);
assert_eq!(
ConsensusGate::Failed("err".into()),
ConsensusGate::Failed("err".into())
);
assert_ne!(ConsensusGate::Pending, ConsensusGate::Ready);
}
#[test]
fn test_consensus_gate_clone() {
let gate = ConsensusGate::Failed("test error".into());
let cloned = gate.clone();
assert_eq!(gate, cloned);
}
#[test]
fn test_verified_ordering_new() {
let node_keys = vec![NodePublicKey(vec![1, 2, 3]), NodePublicKey(vec![4, 5, 6])];
let client_keys = vec![NodePublicKey(vec![7, 8, 9])];
let ordering = VerifiedOrdering::new(node_keys.clone(), client_keys.clone());
assert_eq!(ordering.node_count(), 2);
assert_eq!(ordering.client_count(), 1);
}
#[test]
fn test_verified_ordering_party_id_for_node() {
let pk_a = NodePublicKey(vec![1, 2, 3]);
let pk_b = NodePublicKey(vec![4, 5, 6]);
let ordering = VerifiedOrdering::new(vec![pk_a.clone(), pk_b.clone()], vec![]);
assert_eq!(ordering.party_id_for_node(&pk_a), Some(0));
assert_eq!(ordering.party_id_for_node(&pk_b), Some(1));
assert_eq!(
ordering.party_id_for_node(&NodePublicKey(vec![9, 9, 9])),
None
);
}
#[test]
fn test_verified_ordering_client_id_for_client() {
let ck_a = NodePublicKey(vec![10, 20]);
let ck_b = NodePublicKey(vec![30, 40]);
let ordering = VerifiedOrdering::new(vec![], vec![ck_a.clone(), ck_b.clone()]);
assert_eq!(ordering.client_id_for_client(&ck_a), Some(0));
assert_eq!(ordering.client_id_for_client(&ck_b), Some(1));
}
#[test]
fn test_verified_ordering_key_accessors() {
let pk = NodePublicKey(vec![1, 2]);
let ck = NodePublicKey(vec![3, 4]);
let ordering = VerifiedOrdering::new(vec![pk.clone()], vec![ck.clone()]);
assert_eq!(ordering.node_key(0), Some(&pk));
assert_eq!(ordering.node_key(1), None);
assert_eq!(ordering.client_key(0), Some(&ck));
assert_eq!(ordering.client_key(1), None);
assert_eq!(ordering.node_keys(), &[pk]);
assert_eq!(ordering.client_keys(), &[ck]);
}
#[test]
fn test_verified_ordering_empty() {
let ordering = VerifiedOrdering::new(vec![], vec![]);
assert_eq!(ordering.node_count(), 0);
assert_eq!(ordering.client_count(), 0);
assert_eq!(ordering.node_key(0), None);
assert_eq!(ordering.client_key(0), None);
}
}