# Référence API - sdk_common

Ce guide documente toutes les APIs disponibles dans la bibliothèque commune sdk_common pour les Silent Payments.

## Vue d'Ensemble

La bibliothèque sdk_common fournit des types, structures et utilitaires partagés entre les modules SDK de l'écosystème 4NK.

## 1. Types de Base

### Structures Principales

#### Process
```rust
pub struct Process {
    pub id: String,
    pub name: String,
    pub description: Option<String>,
    pub device_id: String,
    pub state: ProcessState,
    pub states: Vec<ProcessState>,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
}
```

#### ProcessState
```rust
pub enum ProcessState {
    Active,
    Inactive,
    Pending,
    Completed,
    Failed,
}
```

#### Member
```rust
pub struct Member {
    pub id: String,
    pub name: String,
    pub public_key: String,
    pub process_id: String,
    pub roles: Vec<String>,
    pub sp_addresses: Option<Vec<String>>,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
}
```

#### ValidationRule
```rust
pub struct ValidationRule {
    pub id: String,
    pub field_name: String,
    pub rule_type: ValidationRuleType,
    pub parameters: Option<serde_json::Value>,
    pub role_id: String,
    pub quorum: Option<u32>,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
}
```

#### ValidationRuleType
```rust
pub enum ValidationRuleType {
    Range,
    Required,
    Format,
    Custom,
}
```

## 2. Fonctions Utilitaires

### Compression et Sérialisation

#### compress_data
```rust
pub fn compress_data(data: &[u8]) -> Result<Vec<u8>, CompressionError>
```
Compresse des données en utilisant l'algorithme DEFLATE (flate2).

**Paramètres :**
- `data` : Données à compresser

**Retour :**
- `Result<Vec<u8>, CompressionError>` : Données compressées ou erreur

**Exemple :**
```rust
use sdk_common::compress_data;

let data = b"données à compresser";
let compressed = compress_data(data)?;
```

#### decompress_data
```rust
pub fn decompress_data(data: &[u8]) -> Result<Vec<u8>, CompressionError>
```
Décompresse des données au format DEFLATE.

**Paramètres :**
- `data` : Données compressées

**Retour :**
- `Result<Vec<u8>, CompressionError>` : Données décompressées ou erreur

**Exemple :**
```rust
use sdk_common::decompress_data;

let decompressed = decompress_data(&compressed_data)?;
```

### Validation

#### validate_process
```rust
pub fn validate_process(process: &Process) -> Result<(), ValidationError>
```
Valide la structure d'un processus.

**Paramètres :**
- `process` : Processus à valider

**Retour :**
- `Result<(), ValidationError>` : Succès ou erreur de validation

#### validate_member
```rust
pub fn validate_member(member: &Member) -> Result<(), ValidationError>
```
Valide la structure d'un membre.

**Paramètres :**
- `member` : Membre à valider

**Retour :**
- `Result<(), ValidationError>` : Succès ou erreur de validation

### Sérialisation

#### serialize_process
```rust
pub fn serialize_process(process: &Process) -> Result<String, SerializationError>
```
Sérialise un processus en JSON.

**Paramètres :**
- `process` : Processus à sérialiser

**Retour :**
- `Result<String, SerializationError>` : JSON sérialisé ou erreur

#### deserialize_process
```rust
pub fn deserialize_process(json: &str) -> Result<Process, SerializationError>
```
Désérialise un processus depuis JSON.

**Paramètres :**
- `json` : JSON à désérialiser

**Retour :**
- `Result<Process, SerializationError>` : Processus désérialisé ou erreur

## 3. Traits et Interfaces

### ProcessOperations
```rust
pub trait ProcessOperations {
    fn create_process(&self, name: &str, device_id: &str) -> Result<Process, SdkError>;
    fn update_process(&self, process: &Process) -> Result<Process, SdkError>;
    fn get_process(&self, id: &str) -> Result<Option<Process>, SdkError>;
    fn list_processes(&self) -> Result<Vec<Process>, SdkError>;
}
```

### MemberOperations
```rust
pub trait MemberOperations {
    fn add_member(&self, member: &Member) -> Result<Member, SdkError>;
    fn update_member(&self, member: &Member) -> Result<Member, SdkError>;
    fn get_member(&self, id: &str) -> Result<Option<Member>, SdkError>;
    fn list_members(&self, process_id: &str) -> Result<Vec<Member>, SdkError>;
}
```

## 4. Gestion des Erreurs

### Types d'Erreurs

#### SdkError
```rust
pub enum SdkError {
    Validation(ValidationError),
    Serialization(SerializationError),
    Compression(CompressionError),
    NotFound(String),
    InvalidInput(String),
    Internal(String),
}
```

#### ValidationError
```rust
pub enum ValidationError {
    InvalidProcess(String),
    InvalidMember(String),
    InvalidRule(String),
    MissingField(String),
    InvalidValue(String),
}
```

#### SerializationError
```rust
pub enum SerializationError {
    InvalidJson(String),
    MissingField(String),
    InvalidType(String),
}
```

#### CompressionError
```rust
pub enum CompressionError {
    CompressionFailed(String),
    DecompressionFailed(String),
    InvalidData(String),
}
```

## 5. Exemples d'Utilisation

### Création d'un Processus
```rust
use sdk_common::{Process, ProcessState, validate_process};

let process = Process {
    id: "process_123".to_string(),
    name: "Mon Processus".to_string(),
    description: Some("Description du processus".to_string()),
    device_id: "device_456".to_string(),
    state: ProcessState::Active,
    states: vec![ProcessState::Active],
    created_at: None,
    updated_at: None,
};

// Valider le processus
validate_process(&process)?;
```

### Compression de Données
```rust
use sdk_common::{compress_data, decompress_data};

// Compresser des données
let original_data = b"données importantes à compresser";
let compressed = compress_data(original_data)?;

// Décompresser les données
let decompressed = decompress_data(&compressed)?;
assert_eq!(original_data, decompressed.as_slice());
```

### Sérialisation JSON
```rust
use sdk_common::{serialize_process, deserialize_process};

let process = Process { /* ... */ };

// Sérialiser en JSON
let json = serialize_process(&process)?;

// Désérialiser depuis JSON
let deserialized_process = deserialize_process(&json)?;
```

## 6. Configuration

### Features Disponibles

```toml
[dependencies]
sdk_common = { git = "https://git.4nkweb.com/4nk/sdk_common.git", features = ["flate2"] }
```

### Variables d'Environnement

```bash
# Niveau de log
RUST_LOG=debug

# Configuration de compression
COMPRESSION_LEVEL=6
```

## 7. Tests

### Tests Unitaires
```bash
# Tous les tests
cargo test

# Tests spécifiques
cargo test compression
cargo test validation
cargo test serialization
```

### Tests d'Intégration
```bash
# Tests d'intégration
cargo test --test integration_tests
```

## 8. Performance

### Métriques de Compression
- **Ratio de compression** : ~70% pour les données textuelles
- **Vitesse de compression** : ~100MB/s
- **Vitesse de décompression** : ~200MB/s

### Optimisations
- Utilisation de `flate2` avec `miniz_oxide` (pure Rust)
- Sérialisation JSON optimisée
- Validation en temps constant

## 9. Sécurité

### Bonnes Pratiques
- Validation systématique des entrées
- Gestion sécurisée des erreurs
- Pas d'exposition d'informations sensibles dans les logs
- Utilisation de types sécurisés

### Audit de Sécurité
- Code audité pour les vulnérabilités
- Tests de sécurité automatisés
- Mise à jour régulière des dépendances

---

**📚 API Reference complète pour sdk_common - Bibliothèque commune pour les Silent Payments** 🚀