diff --git a/src/network.rs b/src/network.rs index 5664f6d..2fd0151 100644 --- a/src/network.rs +++ b/src/network.rs @@ -4,6 +4,7 @@ use serde::{Deserialize, Serialize}; use sp_client::bitcoin::hex::DisplayHex; use sp_client::bitcoin::OutPoint; use tsify::Tsify; +use std::collections::HashMap; use crate::error::AnkError; use crate::pcd::{Pcd, PcdCommitments, Roles}; @@ -68,6 +69,24 @@ impl AnkFlag { } } +impl SyncType { + pub fn as_str(&self) -> &str { + match self { + Self::StateSync => "StateSync", + Self::ProcessSync => "ProcessSync", + Self::MemberSync => "MemberSync", + Self::TxSync => "TxSync", + Self::BlockSync => "BlockSync", + Self::PeerSync => "PeerSync", + Self::RelaySync => "RelaySync", + Self::HealthSync => "HealthSync", + Self::MetricsSync => "MetricsSync", + Self::ConfigSync => "ConfigSync", + Self::CapabilitySync => "CapabilitySync", + } + } +} + /// Message sent to the server to commit some state in a transaction /// Client must first send a commit message with empty validation_tokens /// Relay will ignore a commit message for an update he's not aware of that also bears validation_tokens @@ -214,3 +233,269 @@ impl Envelope { serde_json::to_string(self).unwrap() } } + +// ===== SYNC MESSAGES ===== + +/// Message de synchronisation pour le réseau mesh des relais +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub struct SyncMessage { + pub sync_type: SyncType, + pub relay_id: String, // Identifiant unique du relais + pub timestamp: u64, // Timestamp de création + pub sequence_number: u64, // Numéro de séquence pour l'ordre + pub payload: SyncPayload, // Contenu de la synchronisation + pub signature: Option, // Signature du relais émetteur +} + +impl SyncMessage { + pub fn new(sync_type: SyncType, relay_id: String, payload: SyncPayload) -> Self { + Self { + sync_type, + relay_id, + timestamp: std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_secs(), + sequence_number: 0, // Sera incrémenté par le système + payload, + signature: None, + } + } + + pub fn to_string(&self) -> String { + serde_json::to_string(self).unwrap() + } +} + +/// Types de synchronisation +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub enum SyncType { + // Synchronisation d'état + StateSync, // Synchronisation de l'état global + ProcessSync, // Synchronisation des processus + MemberSync, // Synchronisation des membres + + // Synchronisation de transactions + TxSync, // Synchronisation des transactions + BlockSync, // Synchronisation des blocs + + // Synchronisation de réseau + PeerSync, // Synchronisation des pairs + RelaySync, // Synchronisation des relais + + // Synchronisation de santé + HealthSync, // État de santé du relais + MetricsSync, // Métriques de performance + + // Synchronisation de configuration + ConfigSync, // Synchronisation de configuration + CapabilitySync, // Synchronisation des capacités +} + +/// Contenu des messages de synchronisation +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub enum SyncPayload { + // État global + StateData { + chain_tip: u32, + wallet_balance: u64, + active_processes: u32, + connected_peers: u32, + }, + + // Données de processus + ProcessData { + processes: OutPointProcessMap, + last_update: u64, + }, + + // Données de membres + MemberData { + members: OutPointMemberMap, + last_update: u64, + }, + + // Données de transactions + TransactionData { + txid: String, + height: Option, + confirmed: bool, + sp_outputs: Vec, + }, + + // Données de bloc + BlockData { + height: u32, + hash: String, + timestamp: u64, + tx_count: u32, + }, + + // Données de pairs + PeerData { + peers: Vec, + last_seen: u64, + }, + + // Données de relais + RelayData { + relays: Vec, + network_topology: NetworkTopology, + }, + + // Données de santé + HealthData { + uptime: u64, + memory_usage: u64, + cpu_usage: f64, + active_connections: u32, + last_block_time: u64, + }, + + // Données de métriques + MetricsData { + messages_processed: u64, + transactions_broadcast: u64, + blocks_scanned: u32, + errors_count: u32, + avg_response_time: f64, + }, + + // Données de configuration + ConfigData { + config_hash: String, + features: Vec, + version: String, + }, + + // Données de capacités + CapabilityData { + capabilities: Vec, + supported_networks: Vec, + }, +} + +/// Informations sur un pair +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub struct PeerInfo { + pub address: String, + pub sp_address: String, + pub connected_since: u64, + pub last_activity: u64, + pub message_count: u64, + pub capabilities: Vec, +} + +/// Informations sur un relais +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub struct RelayInfo { + pub relay_id: String, + pub address: String, + pub sp_address: String, + pub version: String, + pub uptime: u64, + pub last_seen: u64, + pub capabilities: Vec, + pub health_status: HealthStatus, +} + +/// Statut de santé d'un relais +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub enum HealthStatus { + Healthy, + Warning, + Critical, + Offline, +} + +/// Topologie du réseau +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub struct NetworkTopology { + pub total_relays: u32, + pub connected_relays: u32, + pub mesh_connections: Vec, + pub network_diameter: u32, + pub avg_latency: f64, +} + +/// Connexion mesh entre relais +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub struct MeshConnection { + pub from_relay: String, + pub to_relay: String, + pub latency: f64, + pub bandwidth: u64, + pub last_heartbeat: u64, +} + +/// Capacité d'un relais +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub struct Capability { + pub name: String, + pub version: String, + pub enabled: bool, + pub parameters: HashMap, +} + +/// Requête de synchronisation +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub struct SyncRequest { + pub request_id: String, + pub relay_id: String, + pub sync_types: Vec, + pub since_timestamp: Option, + pub max_items: Option, +} + +impl SyncRequest { + pub fn new(request_id: String, relay_id: String, sync_types: Vec) -> Self { + Self { + request_id, + relay_id, + sync_types, + since_timestamp: None, + max_items: None, + } + } + + pub fn to_string(&self) -> String { + serde_json::to_string(self).unwrap() + } +} + +/// Réponse de synchronisation +#[derive(Debug, Serialize, Deserialize, Tsify)] +#[tsify(into_wasm_abi, from_wasm_abi)] +pub struct SyncResponse { + pub request_id: String, + pub relay_id: String, + pub success: bool, + pub messages: Vec, + pub error: Option, +} + +impl SyncResponse { + pub fn new(request_id: String, relay_id: String, success: bool) -> Self { + Self { + request_id, + relay_id, + success, + messages: Vec::new(), + error: None, + } + } + + pub fn to_string(&self) -> String { + serde_json::to_string(self).unwrap() + } +}