solana-recover 1.1.3

A comprehensive Solana wallet recovery and account management tool
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

#[cfg(test)]
mod tests {
    use crate::core::{WalletInfo, EmptyAccount, ScanStatus, WalletScanner};
    use solana_sdk::pubkey::Pubkey;
    use std::str::FromStr;

    #[tokio::test]
    async fn test_scan_wallet_success() {
        // Mock connection pool for testing
        let pool = crate::rpc::ConnectionPool::new(
            vec![crate::core::RpcEndpoint {
                url: "https://api.mainnet-beta.solana.com".to_string(),
                priority: 0,
                rate_limit_rps: 100,
                timeout_ms: 5000,
                healthy: true,
            }],
            1
        );
        let scanner = WalletScanner::new(std::sync::Arc::new(pool));
        
        // Test with a known address
        let result = scanner.scan_wallet("11111111111111111111111111111112").await;
        
        assert!(result.is_ok());
        let scan_result = result.unwrap();
        
        // The scan should either complete successfully or fail with an error
        // Both are valid outcomes for a test environment
        match scan_result.status {
            ScanStatus::Completed => {
                assert!(scan_result.result.is_some());
                assert!(scan_result.error_message.is_none());
            }
            ScanStatus::Failed => {
                // If failed, should have an error message
                assert!(scan_result.error_message.is_some() || scan_result.result.is_none());
            }
            ScanStatus::Pending | ScanStatus::InProgress => {
                // These states shouldn't occur after scan completes
                panic!("Scan should not be in Pending or InProgress state after completion");
            }
        }
    }

    #[tokio::test]
    async fn test_scan_wallet_invalid_address() {
        let pool = crate::rpc::ConnectionPool::new(
            vec![crate::core::RpcEndpoint {
                url: "https://api.mainnet-beta.solana.com".to_string(),
                priority: 0,
                rate_limit_rps: 100,
                timeout_ms: 5000,
                healthy: true,
            }],
            1
        );
        let scanner = WalletScanner::new(std::sync::Arc::new(pool));
        
        // Test with invalid address
        let result = scanner.scan_wallet("invalid_address").await;
        
        assert!(result.is_ok());
        let scan_result = result.unwrap();
        assert_eq!(scan_result.status, ScanStatus::Failed);
        assert!(scan_result.result.is_none());
        assert!(scan_result.error_message.is_some());
    }

    #[test]
    fn test_wallet_info_serialization() {
        let wallet_info = WalletInfo {
            address: "11111111111111111111111111111112".to_string(),
            pubkey: Pubkey::from_str("11111111111111111111111111111112").unwrap(),
            total_accounts: 10,
            empty_accounts: 3,
            recoverable_lamports: 5000000,
            recoverable_sol: 0.005,
            empty_account_addresses: vec![
                "11111111111111111111111111111113".to_string(),
                "11111111111111111111111111111114".to_string(),
                "11111111111111111111111111111115".to_string(),
            ],
            scan_time_ms: 1000,
        };

        // Test JSON serialization
        let json = serde_json::to_string(&wallet_info);
        assert!(json.is_ok());

        // Test JSON deserialization
        let deserialized: WalletInfo = serde_json::from_str(&json.unwrap()).expect("Failed to deserialize WalletInfo");
        assert_eq!(deserialized.address, wallet_info.address);
        assert_eq!(deserialized.total_accounts, wallet_info.total_accounts);
        assert_eq!(deserialized.empty_accounts, wallet_info.empty_accounts);
        assert_eq!(deserialized.recoverable_sol, wallet_info.recoverable_sol);
    }

    #[test]
    fn test_empty_account_serialization() {
        let empty_account = EmptyAccount {
            address: "11111111111111111111111111111112".to_string(),
            lamports: 5000000,
            owner: "11111111111111111111111111111111".to_string(),
            mint: Some("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v".to_string()),
        };

        // Test JSON serialization
        let json = serde_json::to_string(&empty_account);
        assert!(json.is_ok());

        // Test JSON deserialization
        let deserialized: EmptyAccount = serde_json::from_str(&json.unwrap()).expect("Failed to deserialize EmptyAccount");
        assert_eq!(deserialized.address, empty_account.address);
        assert_eq!(deserialized.lamports, empty_account.lamports);
        assert_eq!(deserialized.owner, empty_account.owner);
        assert_eq!(deserialized.mint, empty_account.mint);
    }
}