use crate::chain::ChainGrinder;
use crate::chains::Chain;
use hex::FromHex;
pub fn verify_address(chain_id: &str, address: &str, key: &str) -> Result<(), String> {
let chain = Chain::from_id(chain_id)?;
let secret = parse_secret(key)?;
let attempt = crate::chain::GrindAttempt::Secret32(secret);
let derived = chain.finalize(attempt);
if derived.address.eq_ignore_ascii_case(address.trim()) {
Ok(())
} else {
Err(format!(
"key does not derive address\n claimed: {address}\n derived: {}",
derived.address
))
}
}
fn parse_secret(key: &str) -> Result<[u8; 32], String> {
let trimmed = key.trim();
if let Some(bytes) = try_hex(trimmed) {
return bytes;
}
let decoded = bs58::decode(trimmed)
.into_vec()
.map_err(|e| format!("invalid key encoding (not hex or base58): {e}"))?;
match decoded.len() {
32 => {
let mut out = [0u8; 32];
out.copy_from_slice(&decoded);
Ok(out)
}
64 => {
let mut out = [0u8; 32];
out.copy_from_slice(&decoded[..32]);
Ok(out)
}
n => Err(format!(
"decoded key is {n} bytes — expected 32 (secret) or 64 (Solana keypair)"
)),
}
}
fn try_hex(s: &str) -> Option<Result<[u8; 32], String>> {
let stripped = s.strip_prefix("0x").unwrap_or(s);
if !stripped.chars().all(|c| c.is_ascii_hexdigit()) || stripped.len() != 64 {
return None;
}
Some(<[u8; 32]>::from_hex(stripped).map_err(|e| format!("invalid hex key: {e}")))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::chain::ChainGrinder;
use crate::chains::Chain;
#[test]
fn verify_evm_roundtrip() {
let chain = Chain::from_id("evm").unwrap();
let (addr, attempt) = chain.grind_attempt();
let kp = chain.finalize(attempt);
let hex_key = &kp.exports[0].value;
assert!(verify_address("evm", &addr, hex_key).is_ok());
assert!(verify_address("evm", &addr, &format!("0x{hex_key}")).is_ok());
assert!(verify_address("evm", "0xdeadface", hex_key).is_err());
}
}