newton-core 0.4.16

//! ECDSA key generation and loading utilities

use std::path::PathBuf;

use alloy::{
    primitives::Address,
    signers::{
        k256::ecdsa::SigningKey,
        local::{LocalSigner, PrivateKeySigner},
    },
};
use tracing::{debug, info};

use crate::keys::error::{KeyError, KeyResult};
#[cfg(feature = "config")]
use crate::keys::{
    get_ecdsa_key_path,
    storage::{read_key_file, write_key_file},
};

/// Load an ECDSA private key from storage and create a signer
pub fn load_ecdsa_key_from_path(path: &str) -> KeyResult<PrivateKeySigner> {
    debug!("Loading ECDSA key: {}", path);

    let hex_key = read_key_file(&PathBuf::from(path))?;

    // Remove 0x prefix if present
    let hex_key = hex_key.strip_prefix("0x").unwrap_or(&hex_key);
    let key_bytes = hex::decode(hex_key).map_err(KeyError::HexDecode)?;

    // Ensure we have exactly 32 bytes
    if key_bytes.len() != 32 {
        return Err(KeyError::InvalidKey("ECDSA private key must be 32 bytes".to_string()));
    }

    // Create fixed-size array
    let mut private_key_array = [0u8; 32];
    private_key_array.copy_from_slice(&key_bytes);

    // Create signer from private key bytes
    let signer = PrivateKeySigner::from_bytes(&private_key_array.into())
        .map_err(|e| KeyError::EcdsaSigner(eyre::eyre!("Failed to create signer: {}", e)))?;

    debug!("Loaded ECDSA key '{}' with address: {}", path, signer.address());
    Ok(signer)
}

/// Load ECDSA key from keystore file
pub fn load_ecdsa_key_from_keystore(keystore_path: &str, keystore_password: &str) -> KeyResult<PrivateKeySigner> {
    let signer = LocalSigner::decrypt_keystore(keystore_path, keystore_password)
        .map_err(|e| KeyError::EcdsaSigner(eyre::eyre!("Failed to load ECDSA keystore: {}", e)))?;

    Ok(signer)
}

/// Load ECDSA key from hex string
/// Private key is in hex format
pub fn load_operator_ecdsa_key(ecdsa_operator_key: &str) -> KeyResult<PrivateKeySigner> {
    let hex_key = ecdsa_operator_key.strip_prefix("0x").unwrap_or(ecdsa_operator_key);
    hex_key
        .parse::<PrivateKeySigner>()
        .map_err(|e| KeyError::EcdsaSigner(eyre::eyre!("Failed to parse ECDSA key: {}", e)))
}