# SAL Vault

SAL Vault is a comprehensive cryptographic library that provides secure key management, digital signatures, symmetric encryption, Ethereum wallet functionality, and encrypted key-value storage.

## Features

### Core Cryptographic Operations
- **Symmetric Encryption**: ChaCha20Poly1305 AEAD cipher for secure data encryption
- **Key Derivation**: PBKDF2-based key derivation from passwords
- **Digital Signatures**: ECDSA signing and verification using secp256k1 curves
- **Key Management**: Secure keypair generation and storage

### Keyspace Management
- **Multiple Keyspaces**: Organize keys into separate, password-protected spaces
- **Session Management**: Secure session handling with automatic cleanup
- **Keypair Organization**: Named keypairs within keyspaces for easy management

### Ethereum Integration
- **Wallet Functionality**: Create and manage Ethereum wallets from keypairs
- **Transaction Signing**: Sign Ethereum transactions securely
- **Smart Contract Interaction**: Call read functions on smart contracts
- **Multi-Network Support**: Support for different Ethereum networks

### Key-Value Store
- **Encrypted Storage**: Store key-value pairs with automatic encryption
- **Secure Persistence**: Data is encrypted before being written to disk
- **Type Safety**: Strongly typed storage and retrieval operations

### Rhai Scripting Integration
- **Complete API Exposure**: All vault functionality available in Rhai scripts
- **Session Management**: Script-accessible session and keyspace management
- **Cryptographic Operations**: Encryption, signing, and verification in scripts

## Usage

### Basic Cryptographic Operations

```rust
use sal_vault::symmetric::implementation::{encrypt_symmetric, decrypt_symmetric, generate_symmetric_key};

// Generate a symmetric key
let key = generate_symmetric_key();

// Encrypt data
let message = b"Hello, World!";
let encrypted = encrypt_symmetric(&key, message)?;

// Decrypt data
let decrypted = decrypt_symmetric(&key, &encrypted)?;
```

### Keyspace and Keypair Management

```rust
use sal_vault::keyspace::{KeySpace, KeyPair};

// Create a new keyspace
let mut keyspace = KeySpace::new("my_keyspace");

// Add a keypair
keyspace.add_keypair("main_key")?;

// Sign data
if let Some(keypair) = keyspace.keypairs.get("main_key") {
    let message = b"Important message";
    let signature = keypair.sign(message);
    let is_valid = keypair.verify(message, &signature)?;
}
```

### Ethereum Wallet Operations

```rust
use sal_vault::ethereum::wallet::EthereumWallet;
use sal_vault::ethereum::networks::NetworkConfig;

// Create wallet from keypair
let network = NetworkConfig::mainnet();
let wallet = EthereumWallet::from_keypair(&keypair, network)?;

// Get wallet address
let address = wallet.address();
```

### Rhai Scripting

```rhai
// Create and manage keyspaces
create_key_space("personal", "secure_password");
select_keyspace("personal");

// Create and use keypairs
create_keypair("signing_key");
select_keypair("signing_key");

// Sign and verify data
let message = "Important document";
let signature = sign(message);
let is_valid = verify(message, signature);

// Symmetric encryption
let key = generate_key();
let encrypted = encrypt(key, "secret data");
let decrypted = decrypt(key, encrypted);
```

## Security Features

- **Memory Safety**: All sensitive data is handled securely in memory
- **Secure Random Generation**: Uses cryptographically secure random number generation
- **Password-Based Encryption**: Keyspaces are protected with password-derived keys
- **Session Isolation**: Each session maintains separate state and security context
- **Constant-Time Operations**: Critical operations use constant-time implementations

## Error Handling

The library provides comprehensive error handling through the `CryptoError` enum:

```rust
use sal_vault::error::CryptoError;

match some_crypto_operation() {
    Ok(result) => println!("Success: {:?}", result),
    Err(CryptoError::InvalidKeyLength) => println!("Invalid key length provided"),
    Err(CryptoError::EncryptionFailed(msg)) => println!("Encryption failed: {}", msg),
    Err(CryptoError::KeypairNotFound(name)) => println!("Keypair '{}' not found", name),
    Err(e) => println!("Other error: {}", e),
}
```

## Testing

The package includes comprehensive tests covering all functionality:

```bash
# Run all tests
cargo test

# Run specific test categories
cargo test crypto_tests
cargo test rhai_integration_tests
```

**Note**: The Rhai integration tests use global state and are automatically serialized using a test mutex to prevent interference between parallel test runs.

## Dependencies

- `chacha20poly1305`: Symmetric encryption
- `k256`: Elliptic curve cryptography
- `ethers`: Ethereum functionality
- `serde`: Serialization support
- `rhai`: Scripting integration
- `tokio`: Async runtime support

## License

Licensed under the Apache License, Version 2.0.