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

use crate::core::{BatchScanRequest, BatchScanResult, ScanResult, RecoveryRequest, RecoveryResult};
use crate::core::processor::BatchProcessor;
use crate::core::recovery::RecoveryManager;
use crate::api::server::{ScanRequest, ApiResponse};

pub async fn scan_wallet(
    _processor: std::sync::Arc<BatchProcessor>,
    _request: ScanRequest,
) -> ApiResponse<ScanResult> {
    // Access scanner through public method or add a public getter
    ApiResponse {
        success: false,
        data: None,
        error: Some("Direct scanner access not available through handlers. Use API endpoints instead.".to_string()),
    }
}

pub async fn batch_scan(
    processor: std::sync::Arc<BatchProcessor>,
    request: BatchScanRequest,
) -> ApiResponse<BatchScanResult> {
    match processor.process_batch(&request).await {
        Ok(result) => ApiResponse::success(result),
        Err(e) => ApiResponse {
            success: false,
            data: None,
            error: Some(e.to_string()),
        },
    }
}

pub async fn get_scan_status(
    _scan_id: String,
) -> ApiResponse<ScanResult> {
    ApiResponse {
        success: false,
        data: None,
        error: Some("Scan status retrieval not implemented yet".to_string()),
    }
}

pub async fn health_check() -> ApiResponse<String> {
    ApiResponse::success("OK".to_string())
}

// Recovery endpoints
pub async fn recover_sol(
    recovery_manager: std::sync::Arc<RecoveryManager>,
    request: RecoveryRequest,
) -> ApiResponse<RecoveryResult> {
    // Validate request first
    match recovery_manager.validate_recovery_request(&request).await {
        Ok(_) => {
            match recovery_manager.recover_sol(&request).await {
                Ok(result) => ApiResponse::success(result),
                Err(e) => ApiResponse {
                    success: false,
                    data: None,
                    error: Some(e.to_string()),
                },
            }
        }
        Err(e) => ApiResponse {
            success: false,
            data: None,
            error: Some(e.to_string()),
        },
    }
}

pub async fn estimate_recovery_fees(
    recovery_manager: std::sync::Arc<RecoveryManager>,
    accounts: Vec<String>,
) -> ApiResponse<u64> {
    match recovery_manager.estimate_recovery_fees(&accounts).await {
        Ok(fees) => ApiResponse::success(fees),
        Err(e) => ApiResponse {
            success: false,
            data: None,
            error: Some(e.to_string()),
        },
    }
}

pub async fn get_recovery_status(
    recovery_manager: std::sync::Arc<RecoveryManager>,
    recovery_id: uuid::Uuid,
) -> ApiResponse<Option<RecoveryResult>> {
    match recovery_manager.get_recovery_status(&recovery_id).await {
        Ok(result) => ApiResponse::success(result),
        Err(e) => ApiResponse {
            success: false,
            data: None,
            error: Some(e.to_string()),
        },
    }
}