optimizations for faster searching

Author: Emivvvvv

README.md

@@ -1,5 +1,5 @@
 # <img src='images/bitcoin.svg' height='22'> <img src='images/ethereum.png' height='22'> <img src='images/solana.png' height='22'> btc-vanity
-#### v 2.1.0
+#### v 2.1.1
 A blazingly fast vanity address generator written with the Rust programming language.  Supporting Bitcoin (always included), Ethereum, and Solana (via optional features).
 
 With btc-vanity, you can generate wallets that have custom addresses with prefixes, suffixes, substrings, or even regex patterns. It's designed for **speed**, **flexibility**, and **security**.
@@ -237,7 +237,7 @@ println!("Bitcoin regex-matched vanity address:\n\
 
 ## Contributing
 
-Contributions are welcome! If you’d like to improve btc-vanity or add support for additional chains, feel free to open an issue or submit a pull request on GitHub.
+Contributions are welcome! If you'd like to improve btc-vanity or add support for additional chains, feel free to open an issue or submit a pull request on GitHub.
 
 ## Disclaimer
 

src/lib.rs

@@ -90,7 +90,7 @@
 //!          vanity_address.get_comp_address());
 //! ```
 
-pub const BATCH_SIZE: usize = 64;
+pub const BATCH_SIZE: usize = 256;
 
 pub mod cli;
 pub mod error;

src/vanity_addr_generator/comp.rs

@@ -1,5 +1,25 @@
 use memx::{memeq, memmem};
 
+/// Lookup table for ASCII case conversion
+static ASCII_LOWERCASE: [u8; 256] = [
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+    64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+    112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 91, 92, 93, 94, 95,
+    96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+    112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+    128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+    144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+    160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+    176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+    192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+    208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+    224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
+    240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+];
+
 /// Performs a case-sensitive prefix match using the `memx` crate.
 ///
 /// # Arguments
@@ -11,6 +31,10 @@ use memx::{memeq, memmem};
 /// - `false` otherwise.
 #[inline(always)]
 pub fn eq_prefix_memx(addr: &[u8], pat: &[u8]) -> bool {
+    if addr.len() < pat.len() {
+        return false;
+    }
+
     memeq(&addr[..pat.len()], pat)
 }
 
@@ -25,6 +49,10 @@ pub fn eq_prefix_memx(addr: &[u8], pat: &[u8]) -> bool {
 /// - `false` otherwise.
 #[inline(always)]
 pub fn eq_suffix_memx(addr: &[u8], pat: &[u8]) -> bool {
+    if addr.len() < pat.len() {
+        return false;
+    }
+
     let start = addr.len() - pat.len();
     memeq(&addr[start..], pat)
 }
@@ -43,117 +71,143 @@ pub fn contains_memx(addr: &[u8], pat: &[u8]) -> bool {
     memmem(addr, pat).is_some()
 }
 
-/// Performs a case-insensitive prefix match.
+/// Simple, fast case-insensitive prefix match.
 ///
 /// # Arguments
 /// - `data`: The target byte slice to check.
-/// - `pattern`: The prefix byte slice to match against.
+/// - `pattern`: The prefix byte slice to match against (should be lowercase).
 ///
 /// # Returns
 /// - `true` if the beginning of `data` matches `pattern` (case-insensitively).
 /// - `false` otherwise.
 #[inline(always)]
 pub fn eq_prefix_case_insensitive(data: &[u8], pattern: &[u8]) -> bool {
-    if data.len() < pattern.len() {
+    let pattern_len = pattern.len();
+    if data.len() < pattern_len {
         return false;
     }
-    
-    for i in 0..pattern.len() {
-        let a = data[i];
-        let b = pattern[i];
-
-        // Convert `a` to lowercase if it is an uppercase ASCII letter
-        let a = if a.is_ascii_uppercase() {
-            a | 0b00100000
-        } else {
-            a
-        };
-
-        if a != b {
+
+    if pattern_len == 0 {
+        return true;
+    }
+
+    // Simple, efficient byte-by-byte comparison with lookup table
+    for i in 0..pattern_len {
+        if ASCII_LOWERCASE[data[i] as usize] != pattern[i] {
             return false;
         }
     }
-
     true
 }
 
-/// Performs a case-insensitive suffix match.
+/// Simple, fast case-insensitive suffix match.
 ///
 /// # Arguments
 /// - `data`: The target byte slice to check.
-/// - `pattern`: The suffix byte slice to match against.
+/// - `pattern`: The suffix byte slice to match against (should be lowercase).
 ///
 /// # Returns
 /// - `true` if the end of `data` matches `pattern` (case-insensitively).
 /// - `false` otherwise.
 #[inline(always)]
 pub fn eq_suffix_case_insensitive(data: &[u8], pattern: &[u8]) -> bool {
-    if data.len() < pattern.len() {
+    let pattern_len = pattern.len();
+    if data.len() < pattern_len {
         return false;
     }
+
+    if pattern_len == 0 {
+        return true;
+    }
+
+    let start = data.len() - pattern_len;
 
-    let start = data.len() - pattern.len();
-    for i in 0..pattern.len() {
-        let a = data[start + i];
-        let b = pattern[i];
-
-        // Convert `a` to lowercase if it is an uppercase ASCII letter
-        let a = if a.is_ascii_uppercase() {
-            a | 0b00100000
-        } else {
-            a
-        };
-
-        if a != b {
+    // Simple, efficient byte-by-byte comparison with lookup table
+    for i in 0..pattern_len {
+        if ASCII_LOWERCASE[data[start + i] as usize] != pattern[i] {
             return false;
         }
     }
-
     true
 }
 
-/// Performs a case-insensitive substring match (anywhere match).
+/// High-performance case-insensitive substring search with adaptive algorithm selection.
+/// Uses different algorithms based on pattern length for optimal performance.
 ///
 /// # Arguments
 /// - `data`: The target byte slice to check.
-/// - `pattern`: The byte slice to find within `data`.
+/// - `pattern`: The byte slice to find within `data` (should be lowercase).
 ///
 /// # Returns
 /// - `true` if `pattern` is found anywhere within `data` (case-insensitively).
 /// - `false` otherwise.
 #[inline(always)]
 pub fn contains_case_insensitive(data: &[u8], pattern: &[u8]) -> bool {
-    if data.len() < pattern.len() {
+    let data_len = data.len();
+    let pattern_len = pattern.len();
+
+    if data_len < pattern_len {
         return false;
     }
 
-    let pattern_len = pattern.len();
-    let data_len = data.len();
+    if pattern_len == 0 {
+        return true;
+    }
 
-    for start in 0..=(data_len - pattern_len) {
-        let mut found = true;
+    // Fast path for single character search - our biggest optimization win
+    if pattern_len == 1 {
+        let target = pattern[0];
+        return data.iter().any(|&byte| ASCII_LOWERCASE[byte as usize] == target);
+    }
 
-        for i in 0..pattern_len {
-            let a = data[start + i];
-            let b = pattern[i];
+    // For medium patterns (5-16 bytes), use optimized Boyer-Moore
+    if pattern_len <= 16 {
+        // Create bad character table
+        let mut bad_char = [pattern_len; 256];
+        for (i, &byte) in pattern.iter().enumerate() {
+            bad_char[byte as usize] = pattern_len - 1 - i;
+        }
+
+        let mut pos = 0;
+        while pos <= data_len - pattern_len {
+            let mut j = pattern_len;
 
-            // Convert `a` to lowercase if it is an uppercase ASCII letter
-            let a = if a.is_ascii_uppercase() {
-                a | 0b00100000
+            // Check from the end of the pattern
+            while j > 0 {
+                j -= 1;
+                if ASCII_LOWERCASE[data[pos + j] as usize] != pattern[j] {
+                    break;
+                }
+            }
+
+            if j == 0 {
+                return true; // Match found
+            }
+
+            // Use bad character heuristic to skip positions
+            let bad_char_skip = if pos + pattern_len - 1 < data_len {
+                bad_char[ASCII_LOWERCASE[data[pos + pattern_len - 1] as usize] as usize]
             } else {
-                a
+                1
             };
+            pos += bad_char_skip.max(1);
+        }
+
+        return false;
+    }
 
-            if a != b {
-                found = false;
-                break; // Early exit on mismatch
+    // For very small (2-4 bytes) or very large (more than 16 bytes) patterns, use simple scan
+    for start in 0..=(data_len - pattern_len) {
+        let mut matches = true;
+        for i in 0..pattern_len {
+            if ASCII_LOWERCASE[data[start + i] as usize] != pattern[i] {
+                matches = false;
+                break;
             }
         }
-
-        if found {
-            return true; // Return early if a match is found
+        if matches {
+            return true;
         }
     }
-
     false
-}
+}

src/vanity_addr_generator/mod.rs

@@ -6,4 +6,3 @@ pub mod chain;
 pub mod vanity_addr;
 
 mod comp;
-