Struct KeyManager 

pub struct KeyManager;

Main interface for key management operations

This is the recommended API for library integration. It provides simple, safe methods for common key operations.

Implementations

impl KeyManager

pub fn generate_keypair() -> Keypair

Generate a new Solana keypair

Example

use sol_safekey::KeyManager;

let keypair = KeyManager::generate_keypair();
println!("Public key: {}", keypair.pubkey());

pub fn encrypt_with_password( private_key: &str, password: &str, ) -> EncryptionResult<String>

Encrypt a private key with a password

Arguments

• private_key - The private key in base58 string format
• password - The password to use for encryption

Returns

Base64-encoded encrypted string

Example

use sol_safekey::KeyManager;

let keypair = KeyManager::generate_keypair();
let private_key = keypair.to_base58_string();

let encrypted = KeyManager::encrypt_with_password(
    &private_key,
    "my_password"
).unwrap();

pub fn decrypt_with_password( encrypted_data: &str, password: &str, ) -> EncryptionResult<String>

Decrypt a private key with a password

Arguments

• encrypted_data - Base64-encoded encrypted data
• password - The password used for encryption

Returns

The original private key in base58 string format

Example

use sol_safekey::KeyManager;

let encrypted = "..."; // from encryption
let decrypted = KeyManager::decrypt_with_password(
    encrypted,
    "my_password"
).unwrap();

pub fn get_public_key(private_key: &str) -> EncryptionResult<String>

Get public key from a private key

Arguments

• private_key - Private key in base58 string format

Returns

Public key as a base58 string

pub fn keypair_to_encrypted_json( keypair: &Keypair, password: &str, ) -> EncryptionResult<String>

Encrypt a keypair to a JSON keystore format

This creates a standard encrypted keystore file compatible with Solana tools.

Arguments

• keypair - The Solana keypair to encrypt
• password - The password for encryption

Returns

JSON string containing the encrypted keystore

pub fn keypair_from_encrypted_json( json_data: &str, password: &str, ) -> EncryptionResult<Keypair>

Decrypt a keypair from encrypted JSON keystore. 与 GitHub 最新版兼容：优先按「base58 私钥」解密；若解密结果非 UTF-8，再尝试「64 字节 keypair」。

Examples found in repository

examples/test_decrypt.rs (line 79)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let password = if args.len() >= 2 {
        args[1].clone()
    } else {
        eprintln!("Usage: cargo run -p sol-safekey --example test_decrypt <password>");
        std::process::exit(1);
    };

    let keystore_path = if args.len() >= 3 {
        args[2].clone()
    } else {
        "config/dev/keystore.json".to_string()
    };

    let content = std::fs::read_to_string(&keystore_path)
        .unwrap_or_else(|e| {
            eprintln!("Failed to read {}: {}", keystore_path, e);
            std::process::exit(1);
        });

    let data: serde_json::Value = serde_json::from_str(&content).unwrap();
    let encrypted = data["encrypted_private_key"].as_str().unwrap();
    let pubkey = data["public_key"].as_str().unwrap();

    eprintln!("Keystore: {}", keystore_path);
    eprintln!("Public key: {}", pubkey);
    eprintln!("Password len: {}", password.len());

    let key = generate_encryption_key_simple(&password);
    eprintln!("Encryption key: {:02x}{:02x}{:02x}{:02x}...", key[0], key[1], key[2], key[3]);

    match decrypt_key_to_bytes(encrypted, &key) {
        Ok(bytes) => {
            let preview: Vec<String> = bytes.iter().take(16).map(|b| format!("{:02x}", b)).collect();
            eprintln!("Decrypted {} bytes, first 16: {}", bytes.len(), preview.join(" "));
            eprintln!("is_ascii: {}", bytes.iter().all(|b| b.is_ascii()));
            eprintln!("is_utf8: {}", String::from_utf8(bytes.clone()).is_ok());

            // Check if it looks like base58
            let all_base58 = bytes.iter().all(|b| {
                let c = *b as char;
                c.is_ascii() && (
                    c >= '1' && c <= '9' ||
                    c >= 'A' && c <= 'H' ||
                    c >= 'J' && c <= 'N' ||
                    c >= 'P' && c <= 'Z' ||
                    c >= 'a' && c <= 'z'
                )
            });
            eprintln!("all_base58_chars: {}", all_base58);
        }
        Err(e) => eprintln!("decrypt_key_to_bytes failed: {}", e),
    }

    // Also try with trimmed password
    let trimmed = password.trim();
    if trimmed != password {
        eprintln!("\n--- Trying trimmed password (len={}) ---", trimmed.len());
        let key2 = generate_encryption_key_simple(trimmed);
        eprintln!("Encryption key: {:02x}{:02x}{:02x}{:02x}...", key2[0], key2[1], key2[2], key2[3]);

        match decrypt_key_to_bytes(encrypted, &key2) {
            Ok(bytes) => {
                let preview: Vec<String> = bytes.iter().take(16).map(|b| format!("{:02x}", b)).collect();
                eprintln!("Decrypted {} bytes, first 16: {}", bytes.len(), preview.join(" "));
                eprintln!("is_ascii: {}", bytes.iter().all(|b| b.is_ascii()));
                eprintln!("is_utf8: {}", String::from_utf8(bytes.clone()).is_ok());
            }
            Err(e) => eprintln!("decrypt failed: {}", e),
        }

        match KeyManager::keypair_from_encrypted_json(&content, trimmed) {
            Ok(kp) => {
                println!("SUCCESS with trimmed! keypair: {}", kp.pubkey());
                if kp.pubkey().to_string() == pubkey {
                    println!("Public key MATCHES!");
                }
            }
            Err(e) => eprintln!("keypair_from_encrypted_json (trimmed) failed: {}", e),
        }
    }

    match KeyManager::keypair_from_encrypted_json(&content, &password) {
        Ok(kp) => {
            println!("SUCCESS! keypair: {}", kp.pubkey());
            if kp.pubkey().to_string() == pubkey {
                println!("Public key MATCHES!");
            } else {
                println!("WARNING: mismatch! expected {}", pubkey);
            }
        }
        Err(e) => eprintln!("keypair_from_encrypted_json failed: {}", e),
    }
}