agentic-payments 0.1.0

Autonomous multi-agent Ed25519 signature verification with Byzantine fault tolerance
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Deep validation test to verify 100% functionality
//! This test validates actual cryptographic operations work end-to-end

use agentic_payments::prelude::*;
use agentic_payments::error::{CryptoError, ConsensusError};

#[test]
fn test_identity_generation() {
    let identity = AgentIdentity::generate().expect("Failed to generate identity");
    assert!(identity.did().starts_with("did:ap2:"));
    assert_eq!(identity.public_key_base64().len(), 44); // Base64 of 32 bytes
}

#[test]
fn test_signing_and_verification() {
    let identity = AgentIdentity::generate().expect("Failed to generate identity");
    let message = b"test message for deep validation";

    // Sign
    let signature = identity.sign(message).expect("Failed to sign");
    assert_eq!(signature.to_bytes().len(), 64); // Ed25519 signature is 64 bytes

    // Verify with correct key
    let is_valid = identity.verify(message, &signature).expect("Failed to verify");
    assert!(is_valid, "Valid signature should verify");

    // Verify with wrong message fails
    let wrong_message = b"different message";
    let is_valid_wrong = identity.verify(wrong_message, &signature).expect("Failed to verify");
    assert!(!is_valid_wrong, "Wrong message should not verify");
}

#[test]
fn test_keypair_conversion() {
    let identity = AgentIdentity::generate().expect("Failed to generate identity");
    let keypair = identity.to_keypair().expect("Failed to convert to keypair");

    // Verify keypair works
    let message = b"keypair test";
    let signature = keypair.sign(message).expect("Failed to sign with keypair");
    let is_valid = keypair.verify(message, &signature).expect("Failed to verify with keypair");
    assert!(is_valid, "Keypair signature should verify");
}

#[tokio::test]
async fn test_signature_manager() {
    let manager = SignatureManager::new();
    let identity = AgentIdentity::generate().expect("Failed to generate identity");
    let message = b"signature manager test";
    let signature = identity.sign(message).expect("Failed to sign");

    // Batch verification
    let items = vec![
        (identity.verifying_key().clone(), message.to_vec(), signature.clone()),
    ];

    let results = manager.verify_many(items).await.expect("Verification failed");
    assert_eq!(results.len(), 1);
    assert!(results[0].is_valid);

    let stats = manager.cache_stats().await;
    assert!(stats.total_verifications >= 1, "Should have verifications");
}

#[test]
fn test_batch_verification() {
    let batch = BatchVerification::new();
    let identity1 = AgentIdentity::generate().expect("Failed to generate identity 1");
    let identity2 = AgentIdentity::generate().expect("Failed to generate identity 2");

    let msg1 = b"message 1";
    let msg2 = b"message 2";

    let sig1 = identity1.sign(msg1).expect("Failed to sign 1");
    let sig2 = identity2.sign(msg2).expect("Failed to sign 2");

    batch.add(identity1.verifying_key().clone(), msg1.to_vec(), sig1);
    batch.add(identity2.verifying_key().clone(), msg2.to_vec(), sig2);

    let results = batch.verify_all().expect("Batch verification failed");
    assert_eq!(results.total, 2);
    assert_eq!(results.valid, 2);
    assert_eq!(results.invalid, 0);
}

#[test]
fn test_verifiable_credential_creation() {
    let issuer = AgentIdentity::generate().expect("Failed to generate issuer");
    let subject = AgentIdentity::generate().expect("Failed to generate subject");

    let credential = VerifiableCredential::builder()
        .issuer(issuer.did())
        .subject(subject.did())
        .credential_type(CredentialType::PaymentAuthorization)
        .credential_subject(serde_json::json!({
            "max_amount": 1000,
            "currency": "USD"
        }))
        .build()
        .expect("Failed to build credential");

    assert_eq!(credential.issuer, issuer.did());
    assert_eq!(credential.subject, subject.did());
}

#[test]
fn test_intent_mandate_creation() {
    let user = AgentIdentity::generate().expect("Failed to generate user");
    let bot = AgentIdentity::generate().expect("Failed to generate bot");

    let mandate = IntentMandate::builder()
        .issuer(user.did())
        .subject(bot.did())
        .permissions(vec!["purchase".to_string(), "compare_prices".to_string()])
        .constraints(serde_json::json!({
            "max_amount": 100.00,
            "category": "groceries"
        }))
        .build()
        .expect("Failed to build mandate");

    assert_eq!(mandate.issuer, user.did());
    assert_eq!(mandate.subject, bot.did());
    assert_eq!(mandate.permissions.len(), 2);
}

#[test]
fn test_error_conversions() {
    // Test that our error types convert properly
    let crypto_err = CryptoError::InvalidSignature {
        details: "test".to_string()
    };
    let _main_err: Error = crypto_err.into();

    let consensus_err = ConsensusError::QuorumNotAchieved {
        available: 2,
        required: 3,
    };
    let _main_err: Error = consensus_err.into();
}