anya_core/
lib.rs

1//! Anya Core Library
2//!
3//! This is the core library for the Anya system, providing fundamental
4//! functionality for machine learning, Web5 integration, and Bitcoin operations.
5//!
6//! # Architecture
7//!
8//! The library is organized into several main modules:
9//! - `ml`: Machine learning components and AI agent system
10//! - `web5`: Web5 protocol integration and decentralized identity
11//! - `bitcoin`: Bitcoin and Lightning Network functionality
12//! - `dao`: Decentralized autonomous organization components
13//! - `utils`: Common utilities and helper functions
14//!
15//! # Features
16//!
17//! - Advanced ML capabilities with federated learning
18//! - Web5 protocol implementation for decentralized data management
19//! - Bitcoin and Lightning Network support
20//! - DAO governance and voting
21//! - Comprehensive security and privacy features
22//!
23//! # Examples
24//!
25//! ```rust,no_run
26//! use anya_core::{ml, web5, bitcoin, AnyaConfig, AnyaCore};
27//!
28//! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
29//! // Initialize Anya with default configuration
30//! let anya = AnyaCore::default()?;
31//!
32//! // Or with custom configuration
33//! let config = AnyaConfig::default();
34//! let anya_custom = AnyaCore::new(config)?;
35//!
36//! # Ok(())
37//! # }
38//! ```
39
40use std::collections::HashMap;
41use std::error::Error;
42use std::fmt;
43
44pub mod api;
45pub mod bip;
46#[cfg(feature = "rust-bitcoin")]
47pub mod bitcoin;
48pub mod compliance;
49pub mod dao;
50pub mod enterprise;
51pub mod extensions;
52pub mod install;
53pub mod ml;
54pub mod network;
55pub mod security;
56pub mod testing;
57pub mod types;
58pub mod web5;
59pub mod infrastructure;
60pub mod config;
61pub mod core;
62pub mod layer2;
63pub mod tokenomics;
64pub mod tools;
65pub mod web;
66
67// Hardware optimization module
68pub mod hardware_optimization {
69    use std::collections::HashMap;
70
71    #[derive(Debug, Clone)]
72    pub struct HardwareOptimizationManager {
73        optimizations: HashMap<String, bool>,
74    }
75
76    impl Default for HardwareOptimizationManager {
77        fn default() -> Self {
78            Self::new()
79        }
80    }
81
82    impl HardwareOptimizationManager {
83        pub fn new() -> Self {
84            Self {
85                optimizations: HashMap::new(),
86            }
87        }
88
89        pub fn enable_optimization(&mut self, name: &str) {
90            self.optimizations.insert(name.to_string(), true);
91        }
92
93        pub fn is_optimization_enabled(&self, name: &str) -> bool {
94            self.optimizations.get(name).copied().unwrap_or(false)
95        }
96
97        pub fn intel_optimizer(&self) -> Option<intel::IntelOptimizer> {
98            if self.is_optimization_enabled("intel") {
99                Some(intel::IntelOptimizer::new())
100            } else {
101                None
102            }
103        }
104    }
105
106    pub mod intel {
107        use std::time::Duration;
108
109        #[derive(Debug, Clone)]
110        pub struct BatchVerificationConfig {
111            pub batch_size: usize,
112            pub timeout: Duration,
113            pub use_avx: bool,
114            pub use_sse: bool,
115        }
116
117        impl Default for BatchVerificationConfig {
118            fn default() -> Self {
119                Self {
120                    batch_size: 64,
121                    timeout: Duration::from_secs(30),
122                    use_avx: true,
123                    use_sse: true,
124                }
125            }
126        }
127
128        impl BatchVerificationConfig {
129            pub fn new() -> Self {
130                Self::default()
131            }
132
133            pub fn with_batch_size(mut self, size: usize) -> Self {
134                self.batch_size = size;
135                self
136            }
137
138            pub fn with_timeout(mut self, timeout: Duration) -> Self {
139                self.timeout = timeout;
140                self
141            }
142        }
143
144        #[derive(Debug, Clone)]
145        pub struct CpuCapabilities {
146            pub avx2_support: bool,
147            pub kaby_lake_optimized: bool,
148            pub vendor: String,
149            pub model: String,
150        }
151
152        impl Default for CpuCapabilities {
153            fn default() -> Self {
154                Self {
155                    avx2_support: true,
156                    kaby_lake_optimized: false,
157                    vendor: "Intel".to_string(),
158                    model: "i3-7020U".to_string(),
159                }
160            }
161        }
162
163        #[derive(Debug, Clone)]
164        pub struct IntelOptimizer {
165            capabilities: CpuCapabilities,
166        }
167
168        impl Default for IntelOptimizer {
169            fn default() -> Self {
170                Self::new()
171            }
172        }
173
174        impl IntelOptimizer {
175            pub fn new() -> Self {
176                Self {
177                    capabilities: CpuCapabilities::default(),
178                }
179            }
180
181            pub fn capabilities(&self) -> &CpuCapabilities {
182                &self.capabilities
183            }
184
185            #[cfg(feature = "rust-bitcoin")]
186            pub fn verify_transaction_batch(
187                &self,
188                transactions: &[bitcoin::Transaction],
189                config: &BatchVerificationConfig,
190            ) -> Result<Vec<usize>, Box<dyn std::error::Error>> {
191                if transactions.len() > config.batch_size {
192                    return Err("Batch too large".into());
193                }
194                let invalid_indices = Vec::new();
195                for (i, _tx) in transactions.iter().enumerate() {
196                    let _ = i;
197                }
198                Ok(invalid_indices)
199            }
200
201            #[cfg(feature = "rust-bitcoin")]
202            pub fn verify_taproot_transaction(
203                &self,
204                tx: &bitcoin::Transaction,
205            ) -> Result<(), Box<dyn std::error::Error>> {
206                if tx.output.is_empty() {
207                    return Err("Transaction has no outputs".into());
208                }
209                Ok(())
210            }
211        }
212    }
213
214    pub fn optimize_for_hardware() -> bool {
215        true
216    }
217}
218
219// Re-export key types for crate-wide visibility
220#[cfg(feature = "rust-bitcoin")]
221pub use crate::bitcoin::adapters::BitcoinAdapter;
222#[cfg(feature = "rust-bitcoin")]
223pub use crate::bitcoin::interface::BitcoinInterface;
224pub use crate::dao::DaoLevel;
225pub use crate::types::compliance::*;
226
227#[cfg(feature = "hsm")]
228pub use security::hsm;
229#[cfg(not(feature = "hsm"))]
230pub use security::hsm_shim as hsm;
231
232/// Core error type for the Anya system
233#[derive(Debug, Clone, PartialEq, Eq)]
234pub enum AnyaError {
235    ML(String),
236    Web5(String),
237    Bitcoin(String),
238    DAO(String),
239    System(String),
240    Custom(String),
241    Timeout(String),
242    LowConfidence(String),
243    NotFound(String),
244    InvalidInput(String),
245    PerformanceError(String),
246}
247
248impl fmt::Display for AnyaError {
249    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
250        match self {
251            AnyaError::ML(msg) => write!(f, "ML error: {msg}"),
252            AnyaError::Web5(msg) => write!(f, "Web5 error: {msg}"),
253            AnyaError::Bitcoin(msg) => write!(f, "Bitcoin error: {msg}"),
254            AnyaError::DAO(msg) => write!(f, "DAO error: {msg}"),
255            AnyaError::System(msg) => write!(f, "System error: {msg}"),
256            AnyaError::Custom(msg) => write!(f, "Custom error: {msg}"),
257            AnyaError::Timeout(msg) => write!(f, "Timeout error: {msg}"),
258            AnyaError::LowConfidence(msg) => write!(f, "Low confidence error: {msg}"),
259            AnyaError::NotFound(msg) => write!(f, "Not found error: {msg}"),
260            AnyaError::InvalidInput(msg) => write!(f, "Invalid input error: {msg}"),
261            AnyaError::PerformanceError(msg) => write!(f, "Performance error: {msg}"),
262        }
263    }
264}
265
266impl Error for AnyaError {}
267
268#[cfg(feature = "rust-bitcoin")]
269impl From<crate::bitcoin::error::BitcoinError> for AnyaError {
270    fn from(err: crate::bitcoin::error::BitcoinError) -> Self {
271        AnyaError::Bitcoin(err.to_string())
272    }
273}
274
275impl From<String> for AnyaError {
276    fn from(err: String) -> Self {
277        AnyaError::Custom(err)
278    }
279}
280
281impl From<secp256k1::Error> for AnyaError {
282    fn from(err: secp256k1::Error) -> Self {
283        AnyaError::Bitcoin(format!("Secp256k1 error: {err}"))
284    }
285}
286
287impl From<serde_json::Error> for AnyaError {
288    fn from(err: serde_json::Error) -> Self {
289        AnyaError::System(format!("JSON error: {err}"))
290    }
291}
292
293pub type AnyaResult<T> = Result<T, AnyaError>;
294
295#[derive(Debug, Clone, Default)]
296pub struct AnyaConfig {
297    pub ml_config: ml::MLConfig,
298    pub web5_config: web5::Web5Config,
299    #[cfg(feature = "hsm")]
300    pub bitcoin_config: crate::security::hsm::config::HsmConfig,
301    #[cfg(not(feature = "hsm"))]
302    pub bitcoin_config: crate::security::hsm_shim::HsmConfig,
303    pub dao_config: dao::DAOConfig,
304}
305
306pub struct AnyaCore {
307    pub ml_system: Option<ml::MLSystem>,
308    pub web5_manager: Option<web5::Web5Manager>,
309    pub dao_manager: Option<dao::DAOManager>,
310}
311
312impl AnyaCore {
313    pub fn new(config: AnyaConfig) -> AnyaResult<Self> {
314        let ml_system = if config.ml_config.enabled {
315            Some(ml::MLSystem::new(config.ml_config)?)
316        } else {
317            None
318        };
319
320        let web5_manager = if config.web5_config.enabled {
321            match web5::Web5Manager::new(config.web5_config) {
322                Ok(manager) => Some(manager),
323                Err(e) => return Err(AnyaError::Web5(e.to_string())),
324            }
325        } else {
326            None
327        };
328
329        let dao_manager = if config.dao_config.enabled {
330            match dao::DAOManager::new(config.dao_config) {
331                Ok(manager) => Some(manager),
332                Err(e) => {
333                    return Err(AnyaError::Custom(format!(
334                        "Failed to initialize DAO manager: {e}"
335                    )))
336                }
337            }
338        } else {
339            None
340        };
341
342        Ok(Self {
343            ml_system,
344            web5_manager,
345            dao_manager,
346        })
347    }
348
349    pub fn with_defaults() -> AnyaResult<Self> {
350        Self::new(AnyaConfig::default())
351    }
352
353    pub fn is_operational(&self) -> bool {
354        self.ml_system.is_some() || self.web5_manager.is_some() || self.dao_manager.is_some()
355    }
356
357    pub fn get_status(&self) -> AnyaResult<SystemStatus> {
358        let mut status = SystemStatus {
359            ml_enabled: self.ml_system.is_some(),
360            web5_enabled: self.web5_manager.is_some(),
361            bitcoin_enabled: false,
362            dao_enabled: self.dao_manager.is_some(),
363            component_status: Vec::new(),
364            metrics: HashMap::new(),
365        };
366
367        if let Some(ml_system) = &self.ml_system {
368            status
369                .metrics
370                .insert("ml".to_string(), ml_system.get_model_health_metrics());
371        }
372
373        status.component_status.push(ComponentStatus {
374            name: "ml".to_string(),
375            operational: self.ml_system.is_some(),
376            health_score: if self.ml_system.is_some() { 1.0 } else { 0.0 },
377        });
378
379        status.component_status.push(ComponentStatus {
380            name: "web5".to_string(),
381            operational: self.web5_manager.is_some(),
382            health_score: if self.web5_manager.is_some() { 1.0 } else { 0.0 },
383        });
384
385        status.component_status.push(ComponentStatus {
386            name: "dao".to_string(),
387            operational: self.dao_manager.is_some(),
388            health_score: if self.dao_manager.is_some() { 1.0 } else { 0.0 },
389        });
390
391        Ok(status)
392    }
393}
394
395#[derive(Debug, Clone)]
396pub struct SystemStatus {
397    pub ml_enabled: bool,
398    pub web5_enabled: bool,
399    pub bitcoin_enabled: bool,
400    pub dao_enabled: bool,
401    pub component_status: Vec<ComponentStatus>,
402    pub metrics: HashMap<String, HashMap<String, HashMap<String, f64>>>,
403}
404
405#[derive(Debug, Clone)]
406pub struct ComponentStatus {
407    pub name: String,
408    pub operational: bool,
409    pub health_score: f64,
410}
411
412pub mod utils {
413    pub fn generate_id() -> String {
414        format!("id:{:x}", rand::random::<u64>())
415    }
416
417    pub fn log(msg: &str) {
418        println!("[{}] {}", chrono::Utc::now(), msg);
419    }
420}
421
422pub fn version() -> &'static str {
423    env!("CARGO_PKG_VERSION")
424}
425
426#[cfg(feature = "bitcoin_integration")]
427pub mod integration {
428    pub fn bitcoin_enabled() -> bool {
429        true
430    }
431}
432
433#[cfg(test)]
434mod tests {
435    use super::*;
436
437    #[test]
438    fn test_config_default() {
439        let config = AnyaConfig::default();
440        assert!(config.ml_config.enabled);
441        assert!(config.web5_config.enabled);
442        #[cfg(feature = "hsm")]
443        assert!(config.bitcoin_config.general.enabled);
444        #[cfg(not(feature = "hsm"))]
445        {
446            let _ = &config.bitcoin_config;
447        }
448        assert!(config.dao_config.enabled);
449    }
450
451    #[test]
452    fn test_error_display() {
453        let err = AnyaError::ML("test error".to_string());
454        assert_eq!(err.to_string(), "ML error: test error");
455    }
456}
457
458pub fn init() {
459    // Initialize Bitcoin module if needed
460}
461
462pub const VERSION: &str = env!("CARGO_PKG_VERSION");
463
464#[test]
465fn it_works() {
466    assert_eq!(2 + 2, 4);
467}
468
469impl From<web5::Web5Error> for AnyaError {
470    fn from(error: web5::Web5Error) -> Self {
471        AnyaError::Web5(error.to_string())
472    }
473}
474
475#[cfg(feature = "hsm")]
476impl From<crate::security::hsm::HsmError> for AnyaError {
477    fn from(error: crate::security::hsm::HsmError) -> Self {
478        AnyaError::Bitcoin(error.to_string())
479    }
480}
481
482pub const PROTOCOL_VERSION: &str = "2.0.0";
483pub const IMPLEMENTATION_YEAR: u16 = 2025;
484pub const BUILD_ID: &str = env!("CARGO_PKG_VERSION");
485
486pub mod prelude {
487    pub use crate::dao::governance::DaoGovernance;
488    #[cfg(feature = "rust-bitcoin")]
489    pub use crate::bitcoin::adapters::BitcoinAdapter;
490}
491
492mod error;
anya_core/lib.rs

anya_core/
lib.rs
