# 📦 Guide d'Installation - sdk_common

Guide complet pour installer et configurer la bibliothèque commune sdk_common pour les Silent Payments.

## 📋 Prérequis

### Système

- **OS** : Linux (Ubuntu 20.04+, Debian 11+, CentOS 8+), macOS 10.15+, Windows 10+
- **Architecture** : x86_64, ARM64 (pour certaines plateformes)
- **RAM** : 2 Go minimum, 4 Go recommandés
- **Stockage** : 5 Go minimum, 10 Go recommandés
- **Réseau** : Connexion Internet stable pour télécharger les dépendances

### Logiciels

- **Rust** : Version 1.70+ (stable)
- **Cargo** : Inclus avec Rust
- **Git** : Version 2.25+
- **wasm-pack** : Version 0.12+ (pour compilation WASM)
- **Node.js** : Version 18+ (pour tests WASM)

## 🚀 Installation

### 1. Installation de Rust

#### Linux/macOS

```bash
# Installer Rust via rustup
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Recharger l'environnement
source ~/.cargo/env

# Vérifier l'installation
rustc --version
cargo --version
```

#### Windows

```bash
# Télécharger et installer rustup-init.exe depuis
# https://rustup.rs/
# Puis exécuter dans PowerShell :
rustup-init.exe
```

### 2. Installation de wasm-pack

```bash
# Installer wasm-pack
cargo install wasm-pack

# Vérifier l'installation
wasm-pack --version
```

### 3. Configuration SSH (Recommandé)

```bash
# Générer une clé SSH
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_sdk_common -C "sdk-common-automation"

# Ajouter à l'agent SSH
ssh-add ~/.ssh/id_ed25519_sdk_common

# Configurer Git pour utiliser la clé
git config --global core.sshCommand "ssh -i ~/.ssh/id_ed25519_sdk_common"

# Afficher la clé publique pour Gitea
cat ~/.ssh/id_ed25519_sdk_common.pub
```

**Ajouter la clé publique à Gitea :**
1. Aller sur Gitea > Settings > SSH Keys
2. Coller la clé publique
3. Cliquer sur "Add key"

### 4. Clonage du Repository

```bash
# Cloner avec SSH (recommandé)
git clone git@git.4nkweb.com:4nk/sdk_common.git
cd sdk_common

# Ou cloner avec HTTPS
git clone https://git.4nkweb.com/4nk/sdk_common.git
cd sdk_common
```

### 5. Configuration de l'Environnement

```bash
# Créer le fichier de configuration
cp .env.example .env

# Éditer les variables d'environnement
nano .env
```

**Variables d'environnement principales :**

```bash
# Configuration Rust
RUST_LOG=info
RUST_BACKTRACE=1

# Configuration de build
CARGO_PROFILE_RELEASE_OPT_LEVEL=3
CARGO_PROFILE_RELEASE_LTO=true

# Configuration des tests
TEST_TIMEOUT=300
TEST_PARALLEL=true

# Configuration WASM
WASM_PACK_TARGET=web
WASM_PACK_PROFILE=release
```

### 6. Installation des Dépendances

```bash
# Mettre à jour Rust
rustup update

# Installer les dépendances Rust
cargo build

# Installer les dépendances de développement
cargo install cargo-audit
cargo install cargo-tarpaulin
cargo install cargo-watch
```

## 🧪 Tests Post-Installation

### 1. Tests de Compilation

```bash
# Test de compilation en mode debug
cargo build

# Test de compilation en mode release
cargo build --release

# Test de compilation avec toutes les features
cargo build --all-features
```

### 2. Tests Unitaires

```bash
# Tests unitaires de base
cargo test

# Tests avec output détaillé
cargo test -- --nocapture

# Tests avec couverture
cargo tarpaulin --out Html
```

### 3. Tests d'Intégration

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

# Tests de performance
cargo test --test performance

# Tests de sécurité
cargo audit
```

### 4. Tests WASM

```bash
# Compilation WASM
wasm-pack build --target web

# Tests WASM
wasm-pack test --headless --firefox
wasm-pack test --headless --chrome
```

### 5. Tests de Linting

```bash
# Clippy (linter Rust)
cargo clippy -- -D warnings

# Formatage
cargo fmt -- --check

# Audit de sécurité
cargo audit
```

## 🔧 Configuration Avancée

### Configuration Cargo

**`Cargo.toml` - Configuration de base :**

```toml
[package]
name = "sdk_common"
version = "0.1.0"
edition = "2021"
authors = ["4NK Team <team@4nkweb.com>"]
description = "Bibliothèque commune pour les Silent Payments"
license = "MIT"
repository = "https://git.4nkweb.com/4nk/sdk_common"
keywords = ["bitcoin", "silent-payments", "cryptography"]
categories = ["cryptography", "blockchain"]

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
thiserror = "1.0"
log = "0.4"
env_logger = "0.10"

[dev-dependencies]
tokio = { version = "1.0", features = ["full"] }
criterion = "0.5"

[features]
default = ["std"]
std = []
wasm = ["getrandom/js"]
blindbit-wasm = ["wasm", "js-sys", "web-sys"]

[lib]
name = "sdk_common"
crate-type = ["cdylib", "rlib"]
```

### Configuration de Build

**Optimisations de performance :**

```toml
[profile.release]
opt-level = 3
lto = true
codegen-units = 1
panic = "abort"
strip = true

[profile.dev]
opt-level = 0
debug = true
```

### Configuration des Tests

**Configuration des tests dans `Cargo.toml` :**

```toml
[[test]]
name = "integration"
path = "tests/integration.rs"
harness = true

[[test]]
name = "performance"
path = "tests/performance.rs"
harness = true

[[bench]]
name = "benchmarks"
harness = false
```

## 🚨 Dépannage

### Problèmes Courants

#### Erreur de Compilation Rust

```bash
# Mettre à jour Rust
rustup update

# Nettoyer le cache
cargo clean

# Recompiler
cargo build
```

#### Erreur WASM

```bash
# Mettre à jour wasm-pack
cargo install wasm-pack --force

# Nettoyer le build WASM
rm -rf pkg/

# Recompiler WASM
wasm-pack build --target web
```

#### Erreur de Dépendances

```bash
# Mettre à jour les dépendances
cargo update

# Vérifier les vulnérabilités
cargo audit

# Nettoyer et recompiler
cargo clean && cargo build
```

#### Problèmes de Performance

```bash
# Compiler en mode release
cargo build --release

# Activer les optimisations
export RUSTFLAGS="-C target-cpu=native"

# Utiliser LTO
export RUSTFLAGS="-C lto=fat"
```

### Logs et Debug

```bash
# Activer les logs détaillés
export RUST_LOG=debug

# Activer le backtrace
export RUST_BACKTRACE=1

# Exécuter avec logs
cargo run --bin sdk_common
```

## 🔒 Sécurité

### Bonnes Pratiques

1. **Mise à jour régulière** : Maintenir Rust et les dépendances à jour
2. **Audit de sécurité** : Exécuter `cargo audit` régulièrement
3. **Tests de sécurité** : Inclure des tests de sécurité dans la suite de tests
4. **Validation des entrées** : Valider toutes les entrées utilisateur
5. **Gestion des erreurs** : Gérer proprement les erreurs sans exposer d'informations sensibles

### Configuration de Sécurité

```bash
# Activer les vérifications de sécurité
export RUSTFLAGS="-C overflow-checks=on"

# Activer les sanitizers (Linux/macOS)
export RUSTFLAGS="-Z sanitizer=address"

# Tests de sécurité
cargo test --features security-tests
```

## 📊 Monitoring

### Métriques de Build

```bash
# Taille du binaire
ls -lh target/release/libsdk_common.*

# Taille WASM
ls -lh pkg/sdk_common_bg.wasm

# Temps de compilation
time cargo build --release
```

### Métriques de Performance

```bash
# Benchmarks
cargo bench

# Profiling
cargo install flamegraph
cargo flamegraph --bin sdk_common

# Couverture de code
cargo tarpaulin --out Html
```

## 🎯 Prochaines Étapes

### 1. Intégration

- [Guide d'Utilisation](USAGE.md) - Utiliser la bibliothèque
- [Guide de Configuration](CONFIGURATION.md) - Configurer selon vos besoins
- [API Reference](API.md) - Consulter les APIs

### 2. Développement

- [Guide de Développement](DEVELOPMENT.md) - Contribuer au développement
- [Guide des Tests](TESTING.md) - Écrire et exécuter des tests
- [Architecture](ARCHITECTURE.md) - Comprendre l'architecture

### 3. Intégration avec 4NK_node

- [Intégration 4NK_node](INTEGRATION_4NK_NODE.md) - Intégrer avec l'infrastructure
- [Configuration SSH](SSH_SETUP.md) - Configurer SSH pour l'automatisation
- [Push SSH Automatisé](AUTO_SSH_PUSH.md) - Automatiser les déploiements

---

**📦 Installation réussie ! La bibliothèque sdk_common est maintenant prête à être utilisée.** 🚀