rustywallet_export/
json.rs

1//! JSON export functions.
2
3use crate::error::{ExportError, Result};
4use crate::types::{KeyExport, Network};
5use crate::{export_wif, export_hex, HexOptions};
6use rustywallet_keys::prelude::PrivateKey;
7use rustywallet_keys::public_key::PublicKeyFormat;
8use rustywallet_address::{P2PKHAddress, Network as AddrNetwork};
9
10/// Export a private key to JSON format.
11///
12/// # Example
13///
14/// ```rust
15/// use rustywallet_export::{export_json, Network};
16/// use rustywallet_keys::prelude::PrivateKey;
17///
18/// let key = PrivateKey::random();
19/// let json = export_json(&key, Network::Mainnet).unwrap();
20/// println!("{}", json);
21/// ```
22pub fn export_json(key: &PrivateKey, network: Network) -> Result<String> {
23    let export = key_to_export(key, network)?;
24    serde_json::to_string_pretty(&export)
25        .map_err(|e| ExportError::SerializationFailed(e.to_string()))
26}
27
28/// Export multiple private keys to JSON array.
29///
30/// # Example
31///
32/// ```rust
33/// use rustywallet_export::{export_json_batch, Network};
34/// use rustywallet_keys::prelude::PrivateKey;
35///
36/// let keys: Vec<PrivateKey> = (0..3).map(|_| PrivateKey::random()).collect();
37/// let json = export_json_batch(&keys, Network::Mainnet).unwrap();
38/// println!("{}", json);
39/// ```
40pub fn export_json_batch(keys: &[PrivateKey], network: Network) -> Result<String> {
41    let exports: Result<Vec<KeyExport>> = keys
42        .iter()
43        .map(|k| key_to_export(k, network))
44        .collect();
45    
46    serde_json::to_string_pretty(&exports?)
47        .map_err(|e| ExportError::SerializationFailed(e.to_string()))
48}
49
50/// Convert a key to KeyExport struct.
51fn key_to_export(key: &PrivateKey, network: Network) -> Result<KeyExport> {
52    let public_key = key.public_key();
53    
54    let addr_network = match network {
55        Network::Mainnet => AddrNetwork::BitcoinMainnet,
56        Network::Testnet => AddrNetwork::BitcoinTestnet,
57    };
58    
59    let address = P2PKHAddress::from_public_key(&public_key, addr_network)
60        .map_err(|e| ExportError::AddressError(e.to_string()))?
61        .to_string();
62    
63    Ok(KeyExport {
64        address,
65        wif: export_wif(key, network, true),
66        hex: export_hex(key, HexOptions::new()),
67        public_key: public_key.to_hex(PublicKeyFormat::Compressed),
68        network: network.to_string(),
69        compressed: true,
70    })
71}
72
73#[cfg(test)]
74mod tests {
75    use super::*;
76    
77    #[test]
78    fn test_export_json() {
79        let key = PrivateKey::random();
80        let json = export_json(&key, Network::Mainnet).unwrap();
81        
82        // Verify it's valid JSON
83        let parsed: KeyExport = serde_json::from_str(&json).unwrap();
84        assert!(parsed.address.starts_with('1'));
85        assert!(parsed.wif.starts_with('K') || parsed.wif.starts_with('L'));
86    }
87    
88    #[test]
89    fn test_export_json_batch() {
90        let keys: Vec<PrivateKey> = (0..3).map(|_| PrivateKey::random()).collect();
91        let json = export_json_batch(&keys, Network::Mainnet).unwrap();
92        
93        // Verify it's valid JSON array
94        let parsed: Vec<KeyExport> = serde_json::from_str(&json).unwrap();
95        assert_eq!(parsed.len(), 3);
96    }
97}