kangaroo 0.8.0

Pollard's Kangaroo ECDLP solver for secp256k1 using Vulkan/Metal/DX12 compute
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

//! Data provider system for puzzle sources
//!
//! Providers supply puzzle data (pubkey, key range) from external sources.
//! Format: `provider:path` (e.g., `boha:b1000/135`)

#[cfg(feature = "boha")]
mod boha;

#[cfg(not(feature = "boha"))]
use anyhow::anyhow;
use anyhow::Result;

/// Result from resolving a provider reference
#[derive(Debug, Clone)]
pub struct ProviderResult {
    /// Puzzle identifier (e.g., "b1000/135")
    pub id: String,

    /// Compressed public key (33 bytes hex)
    pub pubkey: Option<String>,

    /// Start of key range (hex, without 0x prefix)
    pub start: Option<String>,

    /// End of key range (hex, without 0x prefix) - used for validation
    #[allow(dead_code)]
    pub end: Option<String>,

    /// Key range in bits
    pub range_bits: Option<u32>,
}

/// Resolve a provider reference to puzzle data
///
/// Format: `provider:path`
/// - `boha:b1000/135` - Bitcoin puzzle #135 from boha
///
/// Returns `Ok(None)` if input is not a provider reference.
/// Returns `Err` if provider is recognized but resolution fails.
pub fn resolve(input: &str) -> Result<Option<ProviderResult>> {
    let Some((provider, query)) = input.split_once(':') else {
        return Ok(None);
    };

    // Skip Windows drive paths (single char before colon)
    if provider.len() == 1 {
        return Ok(None);
    }

    match provider {
        #[cfg(feature = "boha")]
        "boha" => boha::resolve(query).map(Some),

        #[cfg(not(feature = "boha"))]
        "boha" => Err(anyhow!(
            "boha provider requires the 'boha' feature. Rebuild with: cargo build --features boha"
        )),

        _ => {
            let _ = query;
            Ok(None)
        }
    }
}

/// List available puzzles from all providers
///
/// Returns tuples of (provider, id, address, range_bits, has_pubkey)
#[cfg(feature = "boha")]
pub fn list_available() -> Vec<(String, String, String, Option<u32>, bool)> {
    boha::list_available()
}

#[cfg(not(feature = "boha"))]
pub fn list_available() -> Vec<(String, String, String, Option<u32>, bool)> {
    vec![]
}

/// Get list of supported provider names
pub fn supported_providers() -> Vec<&'static str> {
    #[cfg(feature = "boha")]
    {
        vec!["boha"]
    }
    #[cfg(not(feature = "boha"))]
    {
        vec![]
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_resolve_not_provider() {
        let result = resolve("just-a-string").unwrap();
        assert!(result.is_none());
    }

    #[test]
    fn test_resolve_windows_path() {
        let result = resolve("C:\\Users\\test").unwrap();
        assert!(result.is_none());
    }
}