guardian-db 0.19.0

High-performance, local-first decentralized database built on Rust and Iroh
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

#[cfg(test)]
mod tests {
    use crate::log::identity::{DefaultIdentificator, Identificator};
    use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey};
    use hex;

    #[tokio::test]
    async fn test_verify_identity_cryptographically() {
        // Cria um identificador e uma identidade válida usando Ed25519 (consistente com Iroh)
        let mut identificator = DefaultIdentificator::new();
        let identity = identificator.create("test_identity");

        println!("Identity created:");
        println!("  ID: {}", identity.id());
        println!("  Public Key: {}", identity.pub_key());
        println!("  ID Signature: {}", identity.signatures().id());
        println!("  PubKey Signature: {}", identity.signatures().pub_key());

        // Verifica se a identidade tem dados válidos
        assert!(!identity.id().is_empty());
        assert!(!identity.pub_key().is_empty());
        assert!(!identity.signatures().id().is_empty());
        assert!(!identity.signatures().pub_key().is_empty());

        // Testa decodificação da chave pública
        let pub_key_bytes = hex::decode(identity.pub_key());
        assert!(pub_key_bytes.is_ok(), "Public key should be valid hex");

        let pub_key_bytes = pub_key_bytes.unwrap();
        assert_eq!(
            pub_key_bytes.len(),
            32,
            "Ed25519 public key should be 32 bytes"
        );

        let mut pk_array = [0u8; 32];
        pk_array.copy_from_slice(&pub_key_bytes);

        let public_key = VerifyingKey::from_bytes(&pk_array);
        assert!(public_key.is_ok(), "Public key should be valid Ed25519 key");

        println!("✅ Identity cryptographic verification test components are valid");
    }

    #[tokio::test]
    async fn test_signature_verification_components() {
        // Teste dos componentes de verificação de assinatura usando Ed25519
        use rand::Rng;

        // Cria uma chave de teste
        let mut sk_bytes = [0u8; 32];
        rand::rng().fill_bytes(&mut sk_bytes);
        let signing_key = SigningKey::from_bytes(&sk_bytes);
        let verifying_key = signing_key.verifying_key();

        // Cria uma mensagem de teste
        let message = b"test message";

        // Assina a mensagem
        let signature = signing_key.sign(message);

        // Verifica a assinatura
        let verification_result = verifying_key.verify(message, &signature);
        assert!(
            verification_result.is_ok(),
            "Signature verification should succeed"
        );

        // Testa parse de assinatura de bytes
        let signature_bytes = signature.to_bytes();
        let parsed_signature = Signature::from_slice(&signature_bytes);
        assert!(parsed_signature.is_ok(), "Signature parsing should succeed");

        // Verifica novamente com a assinatura parsed
        let verification_result2 = verifying_key.verify(message, &parsed_signature.unwrap());
        assert!(
            verification_result2.is_ok(),
            "Parsed signature verification should succeed"
        );

        println!("✅ Ed25519 signature verification components work correctly");
    }
}