use crate::chain::GrindAttempt;
use crate::pattern::Pattern;
use ed25519_dalek::{PublicKey, SecretKey as Ed25519SecretKey};
use rand::rngs::OsRng;
use rand::RngCore;
use ripemd::Ripemd160;
use secp256k1::{Secp256k1, SecretKey};
use sha2::{Digest, Sha256};
pub struct Keypair {
secret: Ed25519SecretKey,
public: PublicKey,
}
impl Keypair {
pub fn new() -> Self {
let mut seed = [0u8; 32];
OsRng.fill_bytes(&mut seed);
Self::from_seed(&seed).expect("random 32-byte seed is always a valid ed25519 secret key")
}
pub fn from_seed(seed: &[u8]) -> Result<Self, ed25519_dalek::SignatureError> {
let secret = Ed25519SecretKey::from_bytes(seed)?;
let public = PublicKey::from(&secret);
Ok(Self { secret, public })
}
pub fn pubkey(&self) -> PublicKey {
self.public
}
pub fn secret(&self) -> &Ed25519SecretKey {
&self.secret
}
}
pub const BASE58_ALPHABET: &str = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
pub const RIPPLE_ALPHABET: &str = "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz";
pub const BECH32_CHARSET: &str = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
pub fn hash160(data: &[u8]) -> [u8; 20] {
let sha = Sha256::digest(data);
let rip = Ripemd160::digest(sha);
let mut out = [0u8; 20];
out.copy_from_slice(&rip);
out
}
pub fn random_secp256k1_secret() -> SecretKey {
SecretKey::new(&mut OsRng)
}
pub fn grind_secp256k1<F>(derive: F) -> (String, GrindAttempt)
where
F: Fn(&SecretKey) -> String,
{
let secret = random_secp256k1_secret();
let address = derive(&secret);
(address, GrindAttempt::Secret32(secret.secret_bytes()))
}
pub fn base58_check_encode(version: u8, payload: &[u8]) -> String {
let mut data = Vec::with_capacity(1 + payload.len() + 4);
data.push(version);
data.extend_from_slice(payload);
let checksum = &Sha256::digest(Sha256::digest(&data))[..4];
data.extend_from_slice(checksum);
bs58::encode(data).into_string()
}
pub fn base58_check_encode_raw(payload: &[u8]) -> String {
let checksum = &Sha256::digest(Sha256::digest(payload))[..4];
let mut data = payload.to_vec();
data.extend_from_slice(checksum);
bs58::encode(data).into_string()
}
pub fn encode_base58_with_alphabet(data: &[u8], alphabet: &str) -> String {
if data.is_empty() {
return String::new();
}
let mut digits = vec![0u8];
for &byte in data {
let mut carry = byte as u32;
for digit in &mut digits {
carry += (*digit as u32) * 256;
*digit = (carry % 58) as u8;
carry /= 58;
}
while carry > 0 {
digits.push((carry % 58) as u8);
carry /= 58;
}
}
let mut encoded = String::new();
for &byte in data {
if byte == 0 {
encoded.push(alphabet.chars().next().unwrap());
} else {
break;
}
}
for &digit in digits.iter().rev() {
let ch = alphabet.chars().nth(digit as usize).unwrap_or_else(|| {
panic!(
"base58 digit {digit} out of range for alphabet len {}",
alphabet.len()
)
});
encoded.push(ch);
}
encoded
}
pub fn p2pkh_address(secret: &SecretKey, version: u8) -> String {
let secp = Secp256k1::new();
p2pkh_address_from_pubkey(&secret.public_key(&secp), version)
}
pub fn p2pkh_address_from_pubkey(pubkey: &secp256k1::PublicKey, version: u8) -> String {
let hash = hash160(&pubkey.serialize());
base58_check_encode(version, &hash)
}
pub fn validate_chars(label: &str, pattern: &str, allowed: &str) -> Result<String, String> {
if pattern.is_empty() {
return Err(format!("'{label}' cannot be empty"));
}
for c in pattern.chars() {
if c == '*' {
continue; }
if !allowed.contains(c) {
return Err(format!(
"'{label}' contains '{c}' — allowed: {allowed} (and *)"
));
}
}
Ok(pattern.to_string())
}
fn literal_char_count(s: &str) -> usize {
s.chars().filter(|c| *c != '*').count()
}
pub fn build_base58_pattern(
prefix: Option<&str>,
suffix: Option<&str>,
contains: Option<&str>,
exact: bool,
allowed: &str,
max_len: usize,
) -> Result<Pattern, String> {
let prefix_raw = prefix.unwrap_or("").to_string();
let suffix_raw = suffix.unwrap_or("").to_string();
let contains_raw = contains.unwrap_or("").to_string();
if prefix_raw.is_empty() && suffix_raw.is_empty() && contains_raw.is_empty() {
return Err("Provide at least one of --prefix, --suffix, or --contains".into());
}
let prefix = if prefix_raw.is_empty() {
String::new()
} else {
let validated = validate_chars("prefix", &prefix_raw, allowed)?;
if literal_char_count(&validated) > max_len {
return Err(format!("prefix is too long (max {max_len} characters)"));
}
validated
};
let suffix = if suffix_raw.is_empty() {
String::new()
} else {
let validated = validate_chars("suffix", &suffix_raw, allowed)?;
if literal_char_count(&validated) > max_len {
return Err(format!("suffix is too long (max {max_len} characters)"));
}
validated
};
let contains = if contains_raw.is_empty() {
String::new()
} else {
let validated = validate_chars("contains", &contains_raw, allowed)?;
if literal_char_count(&validated) > max_len {
return Err(format!("contains is too long (max {max_len} characters)"));
}
validated
};
if !prefix.is_empty()
&& !suffix.is_empty()
&& literal_char_count(&prefix) + literal_char_count(&suffix) > max_len
{
return Err(format!(
"prefix + suffix length ({}) exceeds {max_len} characters",
literal_char_count(&prefix) + literal_char_count(&suffix)
));
}
let (prefix_match, suffix_match, contains_match) = if exact {
(prefix.clone(), suffix.clone(), contains.clone())
} else {
(
prefix.to_ascii_lowercase(),
suffix.to_ascii_lowercase(),
contains.to_ascii_lowercase(),
)
};
Ok(Pattern {
prefix,
suffix,
contains,
prefix_match,
suffix_match,
contains_match,
ignore_case: !exact,
fixed_prefix_len: 0,
})
}
pub fn build_hex_pattern(
prefix: Option<&str>,
suffix: Option<&str>,
contains: Option<&str>,
with_0x_prefix: bool,
max_hex_len: usize,
) -> Result<Pattern, String> {
let prefix_raw = prefix.unwrap_or("").to_string();
let suffix_raw = suffix.unwrap_or("").to_string();
let contains_raw = contains.unwrap_or("").to_string();
if prefix_raw.is_empty() && suffix_raw.is_empty() && contains_raw.is_empty() {
return Err("Provide at least one of --prefix, --suffix, or --contains".into());
}
let normalize = |label: &str, input: &str| -> Result<String, String> {
let stripped = input.strip_prefix("0x").unwrap_or(input);
let normalized = stripped.to_ascii_lowercase();
if normalized.is_empty() {
return Err(format!("'{label}' cannot be empty"));
}
for c in normalized.chars() {
if c == '*' {
continue;
}
if !c.is_ascii_hexdigit() {
return Err(format!(
"'{label}' contains '{c}' — must be hex (0-9, a-f) or *"
));
}
}
Ok(normalized)
};
let prefix = if prefix_raw.is_empty() {
String::new()
} else {
let normalized = normalize("prefix", &prefix_raw)?;
if literal_char_count(&normalized) > max_hex_len {
return Err(format!("prefix is too long (max {max_hex_len} hex chars)"));
}
if with_0x_prefix {
format!("0x{normalized}")
} else {
normalized
}
};
let suffix = if suffix_raw.is_empty() {
String::new()
} else {
let normalized = normalize("suffix", &suffix_raw)?;
if literal_char_count(&normalized) > max_hex_len {
return Err(format!("suffix is too long (max {max_hex_len} hex chars)"));
}
normalized
};
let contains = if contains_raw.is_empty() {
String::new()
} else {
let normalized = normalize("contains", &contains_raw)?;
if literal_char_count(&normalized) > max_hex_len {
return Err(format!(
"contains is too long (max {max_hex_len} hex chars)"
));
}
normalized
};
let prefix_hex_len = literal_char_count(prefix.strip_prefix("0x").unwrap_or(&prefix));
if !prefix.is_empty()
&& !suffix.is_empty()
&& prefix_hex_len + literal_char_count(&suffix) > max_hex_len
{
return Err(format!(
"prefix + suffix length ({}) exceeds {max_hex_len} hex characters",
prefix_hex_len + literal_char_count(&suffix)
));
}
let fixed_prefix_len = if with_0x_prefix && !prefix.is_empty() {
2
} else {
0
};
Ok(Pattern {
prefix: prefix.clone(),
suffix: suffix.clone(),
contains: contains.clone(),
prefix_match: prefix,
suffix_match: suffix,
contains_match: contains,
ignore_case: true,
fixed_prefix_len,
})
}
pub fn alphabet_char_expected(c: char, ignore_case: bool, alphabet: &str) -> f64 {
let size = alphabet.len() as f64;
let mut matches: f64 = 0.0;
if alphabet.contains(c) {
matches += 1.0;
}
if ignore_case && c.is_ascii_alphabetic() {
let other = if c.is_ascii_lowercase() {
c.to_ascii_uppercase()
} else {
c.to_ascii_lowercase()
};
if other != c && alphabet.contains(other) {
matches += 1.0;
}
}
size / matches.max(1.0)
}
pub fn alphabet_combinations(pattern: &str, ignore_case: bool, alphabet: &str) -> f64 {
pattern
.chars()
.filter(|c| *c != '*')
.map(|c| alphabet_char_expected(c, ignore_case, alphabet))
.product()
}
#[allow(dead_code)] pub fn base58_combinations(pattern: &str) -> f64 {
alphabet_combinations(pattern, false, BASE58_ALPHABET)
}
pub fn hex_combinations(pattern: &str) -> f64 {
let hex = pattern.strip_prefix("0x").unwrap_or(pattern);
16f64.powi(literal_char_count(hex) as i32)
}
pub fn bech32_combinations(pattern: &str) -> f64 {
32f64.powi(literal_char_count(pattern) as i32)
}
pub fn base32_combinations(pattern: &str) -> f64 {
32f64.powi(literal_char_count(pattern) as i32)
}
pub const BASE32_ALPHABET: &str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
pub const BASE32_ALPHABET_LOWER: &str = "abcdefghijklmnopqrstuvwxyz234567";
pub const BASE64URL_ALPHABET: &str =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
#[allow(dead_code)] pub fn base64url_combinations(pattern: &str) -> f64 {
alphabet_combinations(pattern, false, BASE64URL_ALPHABET)
}
pub fn der_ed25519_spki(pubkey: &[u8; 32]) -> Vec<u8> {
let mut der = vec![
0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00,
];
der.extend_from_slice(pubkey);
der
}
pub fn blake2b_var(data: &[u8], out_len: usize) -> Vec<u8> {
use blake2::digest::{Update, VariableOutput};
use blake2::Blake2bVar;
let mut hasher = Blake2bVar::new(out_len).expect("valid blake2b length");
hasher.update(data);
let mut out = vec![0u8; out_len];
hasher
.finalize_variable(&mut out)
.expect("blake2b finalize");
out
}
fn cashaddr_polymod(values: impl Iterator<Item = u8>) -> u64 {
let mut c: u64 = 1;
for d in values {
let c0 = c >> 35;
c = ((c & 0x0007_ffff_ffff) << 5) ^ (d as u64);
if c0 & 0x01 != 0 {
c ^= 0x98f2bc8e61;
}
if c0 & 0x02 != 0 {
c ^= 0x79b76d99e2;
}
if c0 & 0x04 != 0 {
c ^= 0xf33e5fb3c4;
}
if c0 & 0x08 != 0 {
c ^= 0xae2eabe2a8;
}
if c0 & 0x10 != 0 {
c ^= 0x1e4f43e470;
}
}
c ^ 1
}
fn conv8to5(payload: &[u8]) -> Vec<u8> {
let padding = usize::from(!payload.len().is_multiple_of(5));
let mut out = vec![0u8; payload.len() * 8 / 5 + padding];
let mut idx = 0;
let mut buf: u16 = 0;
let mut bits = 0u32;
for &byte in payload {
buf = (buf << 8) | u16::from(byte);
bits += 8;
while bits >= 5 {
bits -= 5;
out[idx] = (buf >> bits) as u8;
buf &= (1 << bits) - 1;
idx += 1;
}
}
if bits > 0 {
out[idx] = (buf << (5 - bits)) as u8;
}
out
}
pub fn kaspa_address_data(prefix: &str, version: u8, payload: &[u8]) -> String {
let mut versioned = Vec::with_capacity(1 + payload.len());
versioned.push(version);
versioned.extend_from_slice(payload);
let fivebit_payload = conv8to5(&versioned);
let fivebit_prefix = prefix.as_bytes().iter().copied().map(|c| c & 0x1f);
let checksum = cashaddr_polymod(
fivebit_prefix
.chain([0u8])
.chain(fivebit_payload.iter().copied())
.chain([0u8; 8]),
);
let checksum5 = conv8to5(&checksum.to_be_bytes()[3..]);
let chars: Vec<char> = BECH32_CHARSET.chars().collect();
fivebit_payload
.iter()
.chain(checksum5.iter())
.map(|&i| chars[i as usize])
.collect()
}
pub fn crc16_xmodem(data: &[u8]) -> u16 {
let mut crc: u16 = 0;
for &b in data {
crc ^= u16::from(b) << 8;
for _ in 0..8 {
if crc & 0x8000 != 0 {
crc = (crc << 1) ^ 0x1021;
} else {
crc <<= 1;
}
}
}
crc
}
pub fn apply_address_start(
pattern: &mut Pattern,
chain_name: &str,
fixed: &str,
next: &[&str],
) -> Result<(), String> {
if !pattern.has_prefix() {
return Ok(());
}
let ignore_case = pattern.ignore_case;
let same = |a: char, b: char| a == b || (ignore_case && a.eq_ignore_ascii_case(&b));
let starts_with = |s: &str, head: &str, wildcard: bool| {
s.chars().count() >= head.chars().count()
&& s.chars()
.zip(head.chars())
.all(|(c, h)| same(c, h) || (wildcard && c == '*'))
};
let after_fixed = if starts_with(&pattern.prefix, fixed, false) {
pattern.prefix[fixed.len()..].to_string()
} else {
pattern.prefix.clone()
};
let forced: String = next.iter().take_while(|s| s.len() == 1).copied().collect();
let head = format!("{fixed}{forced}");
let rest = &next[forced.len()..];
let check = |user: &str| -> Result<(), String> {
for (i, (c, allowed)) in user.chars().zip(rest).enumerate() {
if c == '*' || allowed.chars().any(|a| same(c, a)) {
continue;
}
let before = format!("{head}{}", &user[..i]);
let options: Vec<String> = allowed.chars().map(|a| a.to_string()).collect();
return Err(format!(
"{chain_name} addresses can never have '{c}' after '{before}'. The next character is always {}. Try a prefix like '{}…'.",
options.join(" / "),
rest.iter().map(|s| &s[..1]).collect::<String>()
));
}
Ok(())
};
let mut user = after_fixed.as_str();
let mut result = check(user);
if starts_with(&after_fixed, &forced, true) {
let stripped = &after_fixed[forced.len()..];
let stripped_result = check(stripped);
if stripped_result.is_ok() || result.is_err() {
user = stripped;
result = stripped_result;
}
}
result?;
pattern.prefix = format!("{head}{user}");
pattern.prefix_match = if pattern.ignore_case {
pattern.prefix.to_ascii_lowercase()
} else {
pattern.prefix.clone()
};
pattern.set_fixed_prefix(&head);
Ok(())
}
pub fn address_start_factor(pattern: &Pattern, next: &[&str], alphabet: f64) -> f64 {
let rest = next.iter().skip_while(|s| s.len() == 1);
pattern
.user_prefix()
.chars()
.zip(rest)
.filter(|(c, _)| *c != '*')
.map(|(_, allowed)| allowed.len() as f64 / alphabet)
.product()
}
pub fn expected_from_pattern(pattern: &Pattern, per_char: impl Fn(&str) -> f64) -> f64 {
let mut combos = 1.0_f64;
if pattern.has_prefix() {
combos *= per_char(pattern.user_prefix());
}
if pattern.has_suffix() {
combos *= per_char(&pattern.suffix);
}
if pattern.has_contains() {
combos *= per_char(&pattern.contains);
}
combos
}
pub fn matches_pattern(address: &str, pattern: &Pattern, force_lower: bool) -> bool {
let addr = if force_lower || pattern.ignore_case {
address.to_ascii_lowercase()
} else {
address.to_string()
};
crate::pattern::matches_full(
&addr,
&pattern.prefix_match,
&pattern.suffix_match,
&pattern.contains_match,
pattern.ignore_case || force_lower,
)
}
pub fn grind_ed25519<F>(derive: F) -> (String, GrindAttempt)
where
F: Fn(&Keypair) -> String,
{
let keypair = Keypair::new();
let address = derive(&keypair);
(
address,
GrindAttempt::Secret32(secret32_from_keypair(&keypair)),
)
}
pub fn keypair_from_secret(secret: [u8; 32]) -> Keypair {
Keypair::from_seed(&secret).expect("valid ed25519 seed")
}
pub fn secret32_from_keypair(keypair: &Keypair) -> [u8; 32] {
let seed = keypair.secret().to_bytes();
let mut secret = [0u8; 32];
secret.copy_from_slice(&seed);
secret
}
pub fn secret_from_attempt(attempt: GrindAttempt) -> [u8; 32] {
attempt.secret_bytes()
}