Core API Reference

Initialization

The core API provides the main entry point for interacting with the Anya system.

Creating a New Instance

use anya::Anya;
use anyhow::Result;

async fn initialize() -> Result<()> {
    // Create a new instance with default configuration
    let anya = Anya::new().await?;
    
    // Or with custom configuration
    let config = Config::from_file("anya.toml")?;
    let anya = Anya::with_config(config).await?;
    
    // Initialize the system
    anya.init().await?;
    
    Ok(())
}

Configuration

The configuration API allows you to customize Anya's behavior:

Configuration Options

use anya::config::{Config, NetworkType, SecurityLevel};

async fn configure() -> Result {
    let mut config = Config::default();
    
    // Set network type
    config.set_network(NetworkType::Testnet);
    
    // Configure security settings
    config.set_security_level(SecurityLevel::High);
    
    // Set custom data directory
    config.set_data_dir("/path/to/data");
    
    Ok(config)
}

Core Functions

System Management

impl Anya {
    /// Check system status
    pub async fn status(&self) -> Result {
        // Returns current system status
    }
    
    /// Gracefully shutdown the system
    pub async fn shutdown(&self) -> Result<()> {
        // Performs cleanup and shutdown
    }
    
    /// Backup system data
    pub async fn backup(&self, path: &str) -> Result<()> {
        // Creates system backup
    }
}

Event Handling

use anya::events::{EventHandler, SystemEvent};

async fn handle_events(anya: &Anya) -> Result<()> {
    // Subscribe to system events
    anya.events()
        .subscribe(|event: SystemEvent| {
            match event {
                SystemEvent::WalletUpdated(wallet_id) => {
                    println!("Wallet {} updated", wallet_id);
                }
                SystemEvent::TransactionConfirmed(tx_id) => {
                    println!("Transaction {} confirmed", tx_id);
                }
                // Handle other events...
            }
        })
        .await?;
    
    Ok(())
}

Error Handling

use anya::error::AnyaError;

impl Anya {
    /// Handle system errors
    pub async fn handle_error(&self, error: AnyaError) -> Result<()> {
        match error {
            AnyaError::Configuration(e) => {
                // Handle configuration errors
            }
            AnyaError::Network(e) => {
                // Handle network errors
            }
            AnyaError::Security(e) => {
                // Handle security errors
            }
            // Handle other error types...
        }
    }
}

Examples

Complete System Setup

use anya::{Anya, Config};
use anyhow::Result;

#[tokio::main]
async fn main() -> Result<()> {
    // Load configuration
    let config = Config::from_file("anya.toml")?;
    
    // Initialize system
    let anya = Anya::with_config(config).await?;
    
    // Setup event handlers
    anya.events()
        .subscribe(handle_events)
        .await?;
    
    // Initialize components
    anya.init().await?;
    
    // System is ready
    println!("Anya system initialized successfully");
    
    Ok(())
}