Link for individual Generators.

Each Script is designed for a current Model Personal Computer. Please adjust aspects as needed especially when using GPU, Threading, or Muti-processing. If choosing a script that utilizes those functions than please looke up threads and setting based on your setup. Mine is based off a 20-core CPU and Nvidia RTX 4060 Ti GPU. All in factory-built Dell Desktop. No special add-ons. I will be adding videos over next month showing current speeds with this factory-built basic mid-range computer. I will explain and show how to achieve billions of keys a second on this and much more. 

I will be showing how to create a real database with instant searches. 

I will be showing how to join all Cryptos and different types of wallets into a single keyspace. 

I will be showing more advanced methods to break current limits and achieve 10-20 billion keys per second on current system.

For those who understand a lot of this stuff, I will be focusing on basic at first for people just learning. Please check back, what you want is at end. 

LibraryInstaller.py

This will install all necessary libraries after Python 3.11 is installed on your machine.

import subprocess
import sys

# List of required libraries
REQUIRED_PACKAGES = [
   "bitcoin",  
   "ecdsa",    
   "base58",   
   "requests", 
   "tqdm",     
   "platform",
   "psutil",
   "multiprocessing",
   "subprocess",
   "cryptodome",
   "itertools",
   "string",
   "hashlib",
   "logging",
   "time",
   "threading",
   "py2exe",
   "pyinstall",
   "logging",
   "keyboard",
   "datetime",
   "bech32",
   "scrypt",
   "PyQt5", 
   "bip_utils",
   "pycardano",
   "xrpl.core",
   "xrpl.wallet",
   "binascii",
   "pycuda",
   "numpy", 
   "numba",
   "xrpl-py",
   "eth_account",
   "eth_utils",
   "random",
]

def install_and_update_packages(packages):
   """Install and update required Python packages."""
   for package in packages:
       try:
           # Install the package if it's not already installed
           print(f"Checking installation for {package}...")
           subprocess.check_call([sys.executable, "-m", "pip", "install", package])
           
           # Update the package to the latest version
           print(f"Updating {package} to the latest version...")
           subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", package])
           
           print(f"{package} is installed and up to date.")
       except Exception as e:
           print(f"Error installing/updating {package}: {e}")

if __name__ == "__main__":
   print("Starting package installation and update process...")
   install_and_update_packages(REQUIRED_PACKAGES)
   print("All required packages are installed and up to date.")
 

HYM3CryptoGen.py

Basic Automated Crypto Generator that generates 5 Bitcoin Types (Wallet Addresses and ALL Keys), 5 Ethereum Types, Solana, Cardano, Doge, 2 XRP Types all from a Single Hex. (Used For Database) Generates Tens of Millions per day. (Works on any Computer)

Features:

Custom ranges, I will share in data section. These can be used to skip if beginning and middle of private key are known. It allows you to check only the keys with a specified beginning and mid-section. it will generate only those keys and jump. Details and specific settings will be shared in Data Sections.

Saves All outputs to files. 

Ends on ESC press. Saves progress and will start exactly where it stopped when restarted. 

Multiple Instances can be run simultaneously on a single PC.

import hashlib
import logging
import base58
import keyboard
import random
import string
import os
import enum
import json
from pycardano import HDWallet, Network, Address
from pycardano.key import PaymentSigningKey, PaymentVerificationKey, StakeSigningKey, StakeVerificationKey
from ecdsa import SigningKey, SECP256k1, ellipticcurve
from xrpl.wallet import Wallet
from xrpl.core import keypairs, addresscodec
from xrpl.core.addresscodec import classic_address_to_xaddress
from xrpl.core.keypairs import derive_classic_address, derive_keypair
from bip_utils import Bip39MnemonicGenerator, Bip39SeedGenerator, Bip44, Bip44Coins, Bip44Changes
from eth_account import Account
from eth_utils import to_checksum_address
import binascii

# ------------------ CONFIGURATION ------------------ #
OUTPUT_FOLDER = r"c:\HYM3CryptoTools\uncheckedkeys\Total\Crypto\1"
LOG_FILE = os.path.join(OUTPUT_FOLDER, "progress.log")
RECOVERY_FILE = os.path.join(OUTPUT_FOLDER, "recovery.log")
MAX_KEYS_PER_FILE = 1
LOG_PROGRESS_INTERVAL = 1_000_000
LOWEST_PRIVATE_KEY = 0x81e6d3726e8250d332ccd94465e12cd5b177ae5cbc955a266c68790001d965c8
HIGHEST_PRIVATE_KEY = 0x81e6d37303cc86912efe417df6fe1ea41d373c54d36be99ea889a8ea7a1179a9

# These values are used for counter logic (unchanged)
SEQUENTIAL_COUNT = 185592264682226060569122324245118976  
SKIP_AMOUNT = 46373278467992782366708721920

os.makedirs(OUTPUT_FOLDER, exist_ok=True)
logging.basicConfig(
   filename=LOG_FILE,
   level=logging.INFO,
   format="%(asctime)s - %(levelname)s - %(message)s",
)

# ------------------ BECH32/BECH32M UTILS ------------------ #
CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"

def bech32_polymod(values):
   generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
   checksum = 1
   for value in values:
       top = checksum >> 25
       checksum = ((checksum & 0x1ffffff) << 5) ^ value
       for i in range(5):
           checksum ^= generator[i] if ((top >> i) & 1) else 0
   return checksum

def bech32_hrp_expand(hrp):
   return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp]

def bech32_create_checksum(hrp, data, spec="bech32"):
   # spec "bech32" uses constant 1; "bech32m" uses constant 0x2bc830a3
   constant = 1 if spec=="bech32" else 0x2bc830a3
   values = bech32_hrp_expand(hrp) + data
   polymod = bech32_polymod(values + [0, 0, 0, 0, 0, 0]) ^ constant
   return [(polymod >> 5*(5-i)) & 31 for i in range(6)]

def bech32_encode(hrp, data, spec="bech32"):
   combined = data + bech32_create_checksum(hrp, data, spec)
   return hrp + "1" + "".join([CHARSET[d] for d in combined])

def convertbits(data, frombits, tobits, pad=True):
   acc, bits, ret, maxv = 0, 0, [], (1 << tobits) - 1
   for value in data:
       acc = (acc << frombits) | value
       bits += frombits
       while bits >= tobits:
           bits -= tobits
           ret.append((acc >> bits) & maxv)
   if pad and bits:
       ret.append((acc << (tobits - bits)) & maxv)
   return ret

def hash160(data):
   return hashlib.new('ripemd160', hashlib.sha256(data).digest()).digest()

# ------------------ TAPROOT OUTPUT KEY ------------------ #
def get_taproot_output_key(vk):
   """
   Computes the Taproot tweaked public key (per a simplified BIP341 procedure):
     1. Get internal public key point P from vk.
     2. Ensure P has an even Y coordinate; if not, use (P.x(), p - P.y()).
     3. Compute tweak = SHA256(P.x() as 32 bytes) mod n.
     4. Compute Q = P + tweak * G.
     5. Ensure Q has an even Y coordinate.
     6. Return Q.x() as a 32-byte value.
   """
   P = vk.pubkey.point
   curve = SECP256k1.curve
   n = SECP256k1.order
   p_val = curve.p() if callable(curve.p) else curve.p
   if P.y() % 2 != 0:
       P = ellipticcurve.Point(curve, P.x(), p_val - P.y(), n)
   internal_key_bytes = P.x().to_bytes(32, 'big')
   tweak = int.from_bytes(hashlib.sha256(internal_key_bytes).digest(), 'big') % n
   G = SECP256k1.generator
   Q = P + tweak * G
   if Q.y() % 2 != 0:
       Q = ellipticcurve.Point(curve, Q.x(), p_val - Q.y(), n)
   return Q.x().to_bytes(32, 'big')

# ------------------ MULTISIG SCRIPT GENERATION ------------------ #
def create_multisig_script(pub_keys, required_sigs):
   # Create a standard multisig script: OP_<required_sigs> <PubKey1> ... <PubKeyN> OP_<N> OP_CHECKMULTISIG
   script = bytes([80 + required_sigs]) + b''.join([b'\x21' + pk for pk in pub_keys]) + bytes([80 + len(pub_keys)]) + b'\xae'
   return script

# ------------------ ADDRESS GENERATION ------------------ #
def private_key_to_all_addresses(hex_private_key):
   private_key_bytes = bytes.fromhex(hex_private_key)
   sk = SigningKey.from_string(private_key_bytes, curve=SECP256k1)
   vk = sk.get_verifying_key()
   pub = vk.to_string()  # 64 bytes: first 32 = x, last 32 = y
   x = pub[:32]
   y = pub[32:]
   # Properly compress public key (choose 0x02 if y is even, else 0x03)
   prefix = b'\x02' if int.from_bytes(y, 'big') % 2 == 0 else b'\x03'
   public_key_compressed = prefix + x
   public_key_uncompressed = b'\x04' + pub

   # SegWit Address (P2WPKH)
   p2wpkh = bech32_encode("bc", [0] + convertbits(hash160(public_key_compressed), 8, 5), spec="bech32")
   # P2TR
   taproot_key = get_taproot_output_key(vk)
   p2tr = bech32_encode("bc", [1] + convertbits(taproot_key, 8, 5), spec="bech32m")

   # Legacy Address:
   legacy_key = base58.b58encode_check(b'\x80' + private_key_bytes).decode()
   legacy_address = base58.b58encode_check(b'\x00' + hash160(public_key_uncompressed)).decode()

   # P2SH (compressed WIF and P2SH-P2WPKH)
   p2sh_key = base58.b58encode_check(b'\x80' + private_key_bytes + b'\x01').decode()
   p2sh_address = base58.b58encode_check(b'\x05' + hash160(public_key_compressed)).decode()

   # ------------------ MULTISIG (2-of-3) as P2WSH ------------------ #
   key2 = SigningKey.generate(curve=SECP256k1).get_verifying_key().to_string()
   key3 = SigningKey.generate(curve=SECP256k1).get_verifying_key().to_string()
   pub2_compressed = (b'\x02' if int.from_bytes(key2[32:], 'big') % 2 == 0 else b'\x03') + key2[:32]
   pub3_compressed = (b'\x02' if int.from_bytes(key3[32:], 'big') % 2 == 0 else b'\x03') + key3[:32]
   multisig_script = create_multisig_script([public_key_compressed, pub2_compressed, pub3_compressed], 2)
   # Label the multisig address as P2WSH (since it is a native SegWit output of the multisig script)
   multisig_address = bech32_encode("bc", [0] + convertbits(hashlib.sha256(multisig_script).digest(), 8, 5), spec="bech32")

   # Return all addresses along with all multisig-related keys and script.
   return (p2wpkh, multisig_address, p2tr,
           legacy_key, legacy_address,
           p2sh_key, p2sh_address,
           public_key_compressed.hex(), taproot_key.hex(),
           pub2_compressed.hex(), pub3_compressed.hex(), multisig_script.hex())

# ------------------ XRP WALLET GENERATION (XRP ED25519 FUNCTIONS) ------------------ #
def generate_xrpED_wallet(current_key: str):
   # Strip '0x' prefix if present and ensure it's a string
   clean_hex_key = current_key.lower().lstrip("0x")

   # Ensure the seed is a 64-character hexadecimal string
   if len(clean_hex_key) != 64 or not all(c in '0123456789abcdefABCDEF' for c in clean_hex_key):
       raise ValueError("Seed must be a 64-character hexadecimal string.")

   # Truncate the hex seed to 32 characters (16 bytes)
   truncated_hex_seed = clean_hex_key[-32:]

   # Generate the seed using the truncated hex seed
   xrpED_seed = keypairs.generate_seed(truncated_hex_seed)

   # Create wallet from xrp_seed
   wallet = Wallet.from_seed(xrpED_seed)

   # Derive classic address
   xrpED_classic_address = wallet.classic_address

   # Derive public and private keys
   xrpED_public_key = wallet.public_key
   xrpED_private_key = wallet.private_key

   # Derive X-address
   xrpED_x_address = wallet.get_xaddress()

   return xrpED_classic_address, xrpED_x_address, xrpED_seed, xrpED_public_key, xrpED_private_key

# ------------------ XRP WALLET GENERATION (XRP SECP256k1 FUNCTIONS) ------------------ #
def generate_xrpSEC_wallet(current_key):
   """
   Generates an XRP wallet (secp256k1) from a 64-character hex private key.
   """
   # Ensure the private key is 64 characters long
   if len(current_key) != 64:
       raise ValueError("The private key must be a 64-character hexadecimal string.")

   xrpSEC_private_key = (current_key)

   # Convert hex private key to bytes
   private_key_bytes = binascii.unhexlify(current_key)

   # Create a SigningKey object from the private key
   xrpSEC_seed = SigningKey.from_string(private_key_bytes, curve=SECP256k1)

   # Obtain the verifying (public) key in compressed format
   verifying_key = xrpSEC_seed.get_verifying_key()
   public_key_bytes = (
       b'\x02' + verifying_key.to_string()[:32]
       if verifying_key.pubkey.point.y() % 2 == 0
       else b'\x03' + verifying_key.to_string()[:32]
   )
   xrpSEC_public_key = public_key_bytes.hex().upper()

   # Derive the classic address from the public key
   xrpSEC_classic_address = keypairs.derive_classic_address(xrpSEC_public_key)

   # Generate the X-address (tag is None for a regular wallet)
   xrpSEC_x_address = addresscodec.classic_address_to_xaddress(
       xrpSEC_classic_address, tag=None, is_test_network=False
   )

   return xrpSEC_classic_address, xrpSEC_x_address, xrpSEC_seed, xrpSEC_public_key, xrpSEC_private_key

# ------------------ ETHEREUM WALLET GENERATION (ETH FUNCTIONS) ------------------ #
def generate_eth_wallets(current_key):
   """
   Generate Ethereum wallets from provided hex entropy.
   
   Returns a tuple containing:
     1. Mnemonic (string)
     2. Seed (bytes)
     3. ETH_Standard_Address
     4. ETH_Standard_Public_Key
     5. ETH_Standard_Private_Key
     6. ETH_Ledger_Address
     7. ETH_Ledger_Public_Key
     8. ETH_Ledger_Private_Key
     9. ETH_MEW_Address
     10. ETH_MEW_Public_Key
     11. ETH_MEW_Private_Key
     12. ETH_Trust_Address
     13. ETH_Trust_Public_Key
     14. ETH_Trust_Private_Key
     15. ETH_Legacy_Address
     16. ETH_Legacy_Public_Key
     17. ETH_Legacy_Private_Key
   """
   # Convert hex entropy to bytes
   try:
       entropy_bytes = bytes.fromhex(current_key)
   except ValueError:
       raise ValueError("The provided hex entropy is not a valid hexadecimal string.")

   # Generate mnemonic and seed
   eth_mnemonic = Bip39MnemonicGenerator().FromEntropy(entropy_bytes)
   eth_mnemonic_str = eth_mnemonic.ToStr()
   seed_bytes = Bip39SeedGenerator(eth_mnemonic_str).Generate()

   # Derive HD wallets for Ethereum using Bip44 standard
   bip44_ctx = Bip44.FromSeed(seed_bytes, Bip44Coins.ETHEREUM)

   # ETH_Standard: m/44'/60'/0'/0/0  (CHAIN_EXT, address index 0)
   standard_ctx = bip44_ctx.Purpose().Coin().Account(0).Change(Bip44Changes.CHAIN_EXT).AddressIndex(0)
   eth_standard_priv = standard_ctx.PrivateKey().Raw().ToHex()
   eth_standard_pub = standard_ctx.PublicKey().RawUncompressed().ToHex()
   eth_standard_addr = to_checksum_address(Account.from_key(eth_standard_priv).address)

   # ETH_Ledger: m/44'/60'/0'/0/1  (CHAIN_EXT, address index 1)
   ledger_ctx = bip44_ctx.Purpose().Coin().Account(0).Change(Bip44Changes.CHAIN_EXT).AddressIndex(1)
   eth_ledger_priv = ledger_ctx.PrivateKey().Raw().ToHex()
   eth_ledger_pub = ledger_ctx.PublicKey().RawUncompressed().ToHex()
   eth_ledger_addr = to_checksum_address(Account.from_key(eth_ledger_priv).address)

   # ETH_MEW: m/44'/60'/0'/0/2  (CHAIN_EXT, address index 2)
   mew_ctx = bip44_ctx.Purpose().Coin().Account(0).Change(Bip44Changes.CHAIN_EXT).AddressIndex(2)
   eth_mew_priv = mew_ctx.PrivateKey().Raw().ToHex()
   eth_mew_pub = mew_ctx.PublicKey().RawUncompressed().ToHex()
   eth_mew_addr = to_checksum_address(Account.from_key(eth_mew_priv).address)

   # ETH_Trust: m/44'/60'/0'/1/0  (CHAIN_INT, address index 0)
   trust_ctx = bip44_ctx.Purpose().Coin().Account(0).Change(Bip44Changes.CHAIN_INT).AddressIndex(0)
   eth_trust_priv = trust_ctx.PrivateKey().Raw().ToHex()
   eth_trust_pub = trust_ctx.PublicKey().RawUncompressed().ToHex()
   eth_trust_addr = to_checksum_address(Account.from_key(eth_trust_priv).address)

   # ETH_Legacy: m/44'/60'/0'/0/3  (CHAIN_EXT, address index 3)
   legacy_ctx = bip44_ctx.Purpose().Coin().Account(0).Change(Bip44Changes.CHAIN_EXT).AddressIndex(3)
   eth_legacy_priv = legacy_ctx.PrivateKey().Raw().ToHex()
   eth_legacy_pub = legacy_ctx.PublicKey().RawUncompressed().ToHex()
   eth_legacy_addr = to_checksum_address(Account.from_key(eth_legacy_priv).address)

   return (eth_mnemonic_str, seed_bytes,
           eth_standard_addr, eth_standard_pub, eth_standard_priv,
           eth_ledger_addr, eth_ledger_pub, eth_ledger_priv,
           eth_mew_addr, eth_mew_pub, eth_mew_priv,
           eth_trust_addr, eth_trust_pub, eth_trust_priv,
           eth_legacy_addr, eth_legacy_pub, eth_legacy_priv)

# ------------------ DOGE WALLET GENERATION (DOGE FUNCTIONS) ------------------ #
def generate_doge_wallet(current_key):
   """
   Generate a valid Dogecoin address and WIF, ensuring correct base58 encoding.
   """
   private_key_bytes = bytes.fromhex(current_key)
   doge_wif = base58.b58encode_check(b'\x9e' + private_key_bytes).decode()
   sk = SigningKey.from_string(private_key_bytes, curve=SECP256k1)
   vk = sk.get_verifying_key()
   pub = vk.to_string()
   prefix = b'\x02' if int.from_bytes(pub[32:], 'big') % 2 == 0 else b'\x03'
   doge_pubkey = prefix + pub[:32]
   
   # Ensure valid base58 encoding
   pubkey_hash = hashlib.new('ripemd160', hashlib.sha256(doge_pubkey).digest()).digest()
   doge_address = base58.b58encode_check(b'\x1e' + pubkey_hash).decode()
   doge_private_key = current_key

   return doge_address, doge_wif, doge_pubkey.hex(), doge_private_key

# ------------------ CARDANO WALLET GENERATION (CARDANO FUNCTIONS) ------------------ #
def generate_cardano_wallet(current_key: str):
   # Validate that the provided entropy is exactly 64 hex characters (256 bits)
   if len(current_key) != 64:
       raise ValueError("Entropy must be a 64-character hex string (256 bits).")
   entropy_bytes = bytes.fromhex(current_key)
   
   # 1. Generate a BIP‑39 mnemonic from the entropy.
   CARD_mnemonic = str(Bip39MnemonicGenerator().FromEntropy(entropy_bytes))
   
   # 2. Create an HD wallet from the mnemonic.
   hdwallet = HDWallet.from_mnemonic(CARD_mnemonic)
   
   # 3. Derive the spending key at m/1852'/1815'/0'/0/0
   hdwallet_spend = hdwallet.derive_from_path("m/1852'/1815'/0'/0/0")
   # Extract the 32-byte private key from the extended private key (xprivate_key)
   payment_private_key_bytes = hdwallet_spend.xprivate_key[:32]
   payment_public_key_bytes = hdwallet_spend.public_key  # already correct length
   
   # 4. Derive the staking key at m/1852'/1815'/0'/2/0
   hdwallet_stake = hdwallet.derive_from_path("m/1852'/1815'/0'/2/0")
   stake_private_key_bytes = hdwallet_stake.xprivate_key[:32]
   stake_public_key_bytes = hdwallet_stake.public_key
   
   # 5. Construct the key objects using pycardano key classes.
   CARD_raw_payment_skey = PaymentSigningKey(payment_private_key_bytes)
   CARD_raw_payment_vkey = PaymentVerificationKey(payment_public_key_bytes)
   CARD_raw_stake_skey = StakeSigningKey(stake_private_key_bytes)
   CARD_raw_stake_vkey = StakeVerificationKey(stake_public_key_bytes)
   
   # 6. Build the payment address from the verification key hashes.
   CARD_payment_address = Address(
       payment_part=CARD_raw_payment_vkey.hash(),
       staking_part=CARD_raw_stake_vkey.hash(),
       network=Network.MAINNET  # Change to Network.TESTNET if desired
   )
   
   # 7. Parse key JSON to extract just the hex string.
   CARD_payment_skey_hex = json.loads(CARD_raw_payment_skey.to_json())["cborHex"]
   CARD_payment_vkey_hex = json.loads(CARD_raw_payment_vkey.to_json())["cborHex"]
   CARD_stake_skey_hex   = json.loads(CARD_raw_stake_skey.to_json())["cborHex"]
   CARD_stake_vkey_hex   = json.loads(CARD_raw_stake_vkey.to_json())["cborHex"]
   
   return CARD_mnemonic, CARD_payment_address, CARD_payment_skey_hex, CARD_payment_vkey_hex, CARD_stake_skey_hex, CARD_stake_vkey_hex

# ------------------ SOLANA WALLET GENERATION (SOLANO FUNCTIONS) ------------------ #
def generate_solana_wallet(current_key: str):
   """
   Generates a Solana wallet using a given 64-character hex string as entropy.
   
   Returns a dict with:
     - mnemonic: the BIP-39 mnemonic phrase.
     - seed: the seed in hex.
     - address: the Solana wallet address (base58 encoded public key).
     - public_key: the public key in hex.
     - private_key: the private key in hex.
   
   Note: The derivation path is not returned because the latest bip_utils
   does not provide a method to retrieve it automatically.
   """
   if len(current_key) != 64:
       raise ValueError("Entropy must be a 64-character hex string representing 256 bits.")
   
   # Convert hex string to bytes and generate mnemonic
   entropy_bytes = bytes.fromhex(current_key)
   SOL_mnemonic = Bip39MnemonicGenerator().FromEntropy(entropy_bytes)
   
   # Generate seed from mnemonic (empty passphrase by default)
   SOL_seed = Bip39SeedGenerator(SOL_mnemonic).Generate()
   
   # Derive Solana wallet using Bip44 (coin type 501 corresponds to Solana)
   bip44_mst_ctx = Bip44.FromSeed(SOL_seed, Bip44Coins.SOLANA)
   bip44_acc_ctx = bip44_mst_ctx.Purpose().Coin().Account(0).Change(Bip44Changes.CHAIN_EXT).AddressIndex(0)
   
   # Retrieve wallet components
   SOL_address = bip44_acc_ctx.PublicKey().ToAddress()  
   SOL_private_key = bip44_acc_ctx.PrivateKey().Raw().ToHex()
   SOL_public_key = bip44_acc_ctx.PublicKey().RawCompressed().ToHex()
   
   return SOL_seed, SOL_address, SOL_public_key, SOL_private_key,  

# ------------------ RECOVERY / FILE SAVING ------------------ #

def increment_hex_key(hex_key):
   """Increments the hex key by a fixed amount."""
   return hex(int(hex_key, 16) + 1)[2:].zfill(64)

def save_recovery_state(current_key, file_index):
   """Saves the recovery state (current key and file index) to a recovery file."""
   with open(RECOVERY_FILE, "w") as f:
       f.write(f"{current_key},{file_index}\n")

def load_recovery_state():
   """Loads the recovery state (current key and file index) from the recovery file."""
   if os.path.exists(RECOVERY_FILE):
       with open(RECOVERY_FILE, "r") as f:
           current_key, file_index = f.read().split(",")
           return hex_key.strip(), int(file_index.strip())
   # Return the initial key and file index if recovery file doesn't exist
   return format(LOWEST_PRIVATE_KEY, '064x'), 1

def save_to_file(current_key, file_index, keys):
   """Saves generated keys to a file."""
   with open(os.path.join(OUTPUT_FOLDER, f"Crypto{file_index}.txt"), "w") as f:
       for key_info in keys:
           try:
               current_key, btc_outputs, xrpED_wallets, xrpSEC_wallets, eth_wallets, doge_wallet, cardano_wallet, sol_wallet = key_info
               f.write(
                   f'Key_Hex:{current_key} '
                   f'BTC_P2WPKH:{btc_outputs[0]} '
                   f'BTC_P2WSH_Multisig:{btc_outputs[1]} '
                   f'BTC_P2TR:{btc_outputs[2]} '
                   f'BTC_Legacy_Key:{btc_outputs[3]} '
                   f'BTC_Legacy_Address:{btc_outputs[4]} '
                   f'BTC_P2SH_Key:{btc_outputs[5]} '
                   f'BTC_P2SH_Address:{btc_outputs[6]} '
                   f'BTC_CompPub:{btc_outputs[7]} '
                   f'BTC_TaprootKey:{btc_outputs[8]} '
                   f'BTC_Multisig_Key2:{btc_outputs[9]} '
                   f'BTC_Multisig_Key3:{btc_outputs[10]} '
                   f'BTC_Multisig_Script:{btc_outputs[11]} '
                   f'XRP_ed25519_Classic_Address:{xrpED_wallets[0]} '
                   f'XRP_ed25519_X-Address:{xrpED_wallets[1]} '
                   f'XRP_ed25519_Seed:{xrpED_wallets[2]} '
                   f'XRP_ed25519_Public_Key:{xrpED_wallets[3]} '
                   f'XRP_ed25519_Private_Key:{xrpED_wallets[4]} '
                   f'XRP_secp256k1_Classic_Address:{xrpSEC_wallets[0]} '
                   f'XRP_secp256k1_X-Address:{xrpSEC_wallets[1]} '
                   f'XRP_secp256k1_Seed:{xrpSEC_wallets[2]} '
                   f'XRP_secp256k1_Public_Key:{xrpSEC_wallets[3]} '
                   f'XRP_secp256k1_Private_Key:{xrpSEC_wallets[4]} '
                   f'DOGE_Address:{doge_wallet[0]} '
                   f'DOGE_WIF:{doge_wallet[1]} '
                   f'DOGE_Public_Key:{doge_wallet[2]} '
                   f'DOGE_Private_Key:{doge_wallet[3]} '
                   f'SOL_Derivation:(m/44/501/0/0/0) '
                   f'SOL_Seed:{sol_wallet[0]} '
                   f'SOL_Address:{sol_wallet[1]} '
                   f'SOL_Public_Key:{sol_wallet[2]} '
                   f'SOL_Private_Key:{sol_wallet[3]} '
                   f'Mnemonic_ALL:{cardano_wallet[0]} '
                   f'CARD_Payment_Address:{cardano_wallet[1]} '
                   f'CARD_Payment_SKey_Hex:{cardano_wallet[2]} '
                   f'CARD_Payment_VKey_Hex:{cardano_wallet[3]} '
                   f'CARD_Stake_SKey_Hex:{cardano_wallet[4]} '
                   f'CARD_Stake_VKey_Hex:{cardano_wallet[5]} '
                   f'ETH_Mnemonic:{eth_wallets[0]} '
                   f'ETH_Seed_Bytes:{eth_wallets[1]} '
                   f'ETH_Standard_Address:{eth_wallets[2]} '
                   f'ETH_Standard_Public_Key:{eth_wallets[3]} '
                   f'ETH_Standard_Private_Key:{eth_wallets[4]} '
                   f'ETH_Ledger_Address:{eth_wallets[5]} '
                   f'ETH_Ledger_Public_Key:{eth_wallets[6]} '
                   f'ETH_Ledger_Private_Key:{eth_wallets[7]} '
                   f'ETH_MEW_Address:{eth_wallets[8]} '
                   f'ETH_MEW_Public_Key:{eth_wallets[9]} '
                   f'ETH_MEW_Private_Key:{eth_wallets[10]} '
                   f'ETH_TRUST_Address:{eth_wallets[11]} '
                   f'ETH_TRUST_Public_Key:{eth_wallets[12]} '
                   f'ETH_TRUST_Private_Key:{eth_wallets[13]} '
                   f'ETH_Legacy_Address:{eth_wallets[14]} '
                   f'ETH_Legacy_Public_Key:{eth_wallets[15]} '
                   f'ETH_Legacy_Private_Key:{eth_wallets[16]} '
               )

           except Exception as e:
               print(f"Error writing key info: {e}")

# ------------------ MAIN LOOP ------------------ #
def main():
   current_key, file_index = load_recovery_state()
   keys = []
   sequential_counter = 0
   counter = 0

   try:
       while int(current_key, 16) <= HIGHEST_PRIVATE_KEY:
           # Generate Bitcoin, Ethereum, XRP, and Dogecoin addresses and other information
           btc_outputs = private_key_to_all_addresses(current_key)
           xrpED_classic_address, xrpED_x_address, xrpED_seed, xrpED_public_key, xrpED_private_key = generate_xrpED_wallet(current_key)
           xrpSEC_classic_address, xrpSEC_x_address, xrpSEC_seed, xrpSEC_public_key, xrpSEC_private_key = generate_xrpSEC_wallet(current_key)
           eth_wallets = generate_eth_wallets(current_key)
           doge_wallet = generate_doge_wallet(current_key)
           cardano_wallet = generate_cardano_wallet(current_key)
           sol_wallet = generate_solana_wallet(current_key)

           # Collect the generated keys and info for this iteration
           keys.append((
               current_key,
               btc_outputs,
               (xrpED_classic_address, xrpED_x_address, xrpED_seed, xrpED_public_key, xrpED_private_key),
               (xrpSEC_classic_address, xrpSEC_x_address, xrpSEC_seed, xrpSEC_public_key, xrpSEC_private_key),
               eth_wallets,
               doge_wallet,
               cardano_wallet,
               sol_wallet
           ))

           # Printing the generated information in real-time
           print(f' Generated for Key           : {current_key}')
           print(f' P2WPKH                      : {btc_outputs[0]}')
           print(f' P2WSH (Multisig)            : {btc_outputs[1]}')
           print(f' P2TR                        : {btc_outputs[2]}')
           print(f' Legacy_Key                  : {btc_outputs[3]}')
           print(f' Legacy_Address              : {btc_outputs[4]}')
           print(f' P2SH_Key                    : {btc_outputs[5]}')
           print(f' P2SH_Address                : {btc_outputs[6]}')
           print(f' CompressedPubKey            : {btc_outputs[7]}')
           print(f' TaprootOutputKey            : {btc_outputs[8]}')
           print(f' Multisig Key 2              : {btc_outputs[9]}')
           print(f' Multisig Key 3              : {btc_outputs[10]}')
           print(f' Multisig_Script             : {btc_outputs[11]}')
           print(f' XRP ED Classic Address      : {xrpED_classic_address}')
           print(f' XRP ED X-Address            : {xrpED_x_address}')
           print(f' XRP ED Seed                 : {xrpED_seed}')
           print(f' XRP ED Public Key           : {xrpED_public_key}')
           print(f' XRP ED Private Key          : {xrpED_private_key}')
           print(f' XRP SEC Classic Address     : {xrpSEC_classic_address}')
           print(f' XRP SEC X-Address           : {xrpSEC_x_address}')
           print(f' XRP SEC Seed                : {xrpSEC_seed}')
           print(f' XRP SEC Public Key          : {xrpSEC_public_key}')
           print(f' XRP SEC Private Key         : {xrpSEC_private_key}')
           print(f' Doge Address                : {doge_wallet[0]}')
           print(f' Doge WIF                    : {doge_wallet[1]}')
           print(f' Doge Public Key             : {doge_wallet[2]}')
           print(f' Doge Private Key            : {doge_wallet[3]}')
           print(f' SOL Seed                    : {sol_wallet[0]}')
           print(f' SOL Address                 : {sol_wallet[1]}')
           print(f' SOL Public Key              : {sol_wallet[2]}')
           print(f' SOL Private Key             : {sol_wallet[3]}')
           print(f' Mnemonic For SOL ETH CARD   : {cardano_wallet[0]}')
           print(f' Cardano Payment Address     : {cardano_wallet[1]}')
           print(f' Cardano Payment SKey Hex    : {cardano_wallet[2]}')
           print(f' Cardano Payment VKey Hex    : {cardano_wallet[3]}')
           print(f' Cardano Stake SKey Hex      : {cardano_wallet[4]}')
           print(f' Cardano Stake VKey Hex      : {cardano_wallet[5]}')
           print(f' ETH_Mnemonic                : {eth_wallets[0]}')
           print(f' ETH_Seed_Bytes              : {eth_wallets[1]}')
           print(f' ETH_Standard_Address        : {eth_wallets[2]}')
           print(f' ETH_Standard_Public_Key     : {eth_wallets[3]}')
           print(f' ETH_Standard_Private_Key    : {eth_wallets[4]}')
           print(f' ETH_Ledger_Address          : {eth_wallets[5]}')
           print(f' ETH_Ledger_Public_Key       : {eth_wallets[6]}')
           print(f' ETH_Ledger_Private_Key      : {eth_wallets[7]}')
           print(f' ETH_MEW_Address             : {eth_wallets[8]}')
           print(f' ETH_MEW_Public_Key          : {eth_wallets[9]}')
           print(f' ETH_MEW_Private_Key         : {eth_wallets[10]}')
           print(f' ETH_TRUST_Address           : {eth_wallets[11]}')
           print(f' ETH_TRUST_Public_Key        : {eth_wallets[12]}')
           print(f' ETH_TRUST_Private_Key       : {eth_wallets[13]}')
           print(f' ETH_Legacy_Address          : {eth_wallets[14]}')
           print(f' ETH_Legacy_Public_Key       : {eth_wallets[15]}')
           print(f' ETH_Legacy_Private_Key      : {eth_wallets[16]}')
           print('------------------------------------------------------------')

           # If the keys list is full, save them to a file
           if len(keys) >= MAX_KEYS_PER_FILE:
               save_to_file(current_key, file_index, keys)
               keys = []
               file_index += 1

           # Increment the key (based on sequential count or skip amount)
           if sequential_counter < SEQUENTIAL_COUNT:
               current_key = hex(int(current_key, 16) + 1)[2:].zfill(64)
               sequential_counter += 1
           else:
               current_key = hex(int(current_key, 16) + SKIP_AMOUNT)[2:].zfill(64)
               sequential_counter = 0

           counter += 1
           if counter % LOG_PROGRESS_INTERVAL == 0:
               logging.info(f"Generated {counter} keys. Current key: {current_key}")

           if keyboard.is_pressed("esc"):
               save_recovery_state(current_key, file_index)
               save_to_file(current_key, file_index, keys)
               print("\nProcess interrupted. Progress saved.")
               break
   except Exception as e:
       logging.error(f"Error: {e}")
       print(f"Error: {e}")

if __name__ == "__main__":
   main()

 

HYM3FileSorter.py 

Separates all Generated information and place it on its own line. (Used For Database along with HYM3CryptoGen.py)

import os
import re

# Paths
input_folder = r"c:\HYM3CryptoTools\uncheckedkeys\total"
sorted_folder = r"c:\HYM3CryptoTools\Sorted\Total"
log_file = os.path.join(sorted_folder, "processing_log.txt")

# Ensure the output folder exists
os.makedirs(sorted_folder, exist_ok=True)

def get_next_file_number():
   """Get the next file number to process based on the log file."""
   if os.path.exists(log_file):
       try:
           with open(log_file, 'r', encoding='utf-8') as f:
               lines = f.readlines()
               if lines:
                   last_line = lines[-1].strip()
                   if last_line.isdigit():
                       return int(last_line) + 1
       except Exception as e:
           print(f"[ERROR] Could not read log file: {e}")
   return 1

def update_log_file(next_file_number):
   """Update the log file with the next file number."""
   try:
       with open(log_file, 'a', encoding='utf-8') as f:
           f.write(f"{next_file_number}\n")
   except Exception as e:
       print(f"[ERROR] Could not update log file: {e}")

# List of expected keys exactly as used in your original code
expected_keys = [
   "Key_Hex", "BTC_P2WPKH", "BTC_P2WSH_Multisig", "BTC_P2TR", "BTC_Legacy_Key", "BTC_Legacy_Address",
   "BTC_P2SH_Key", "BTC_P2SH_Address", "BTC_CompPub", "BTC_TaprootKey", "BTC_Multisig_Key2", "BTC_Multisig_Key3", "BTC_Multisig_Script",
   "XRP_ed25519_Classic_Address", "XRP_ed25519_X-Address", "XRP_ed25519_Seed", "XRP_ed25519_Public_Key", "XRP_ed25519_Private_Key",
   "XRP_secp256k1_Classic_Address", "XRP_secp256k1_X-Address", "XRP_secp256k1_Seed", "XRP_secp256k1_Public_Key", "XRP_secp256k1_Private_Key",
   "DOGE_Address", "DOGE_WIF", "DOGE_Public_Key", "DOGE_Private_Key",
   "SOL_Derivation", "SOL_Seed", "SOL_Address", "SOL_Public_Key", "SOL_Private_Key",
   "Mnemonic_ALL",
   "CARD_Payment_Address", "CARD_Payment_SKey_Hex", "CARD_Payment_VKey_Hex", "CARD_Stake_SKey_Hex", "CARD_Stake_VKey_Hex",
   "ETH_Mnemonic", "ETH_Seed_Bytes", "ETH_Standard_Address", "ETH_Standard_Public_Key", "ETH_Standard_Private_Key",
   "ETH_Ledger_Address", "ETH_Ledger_Public_Key", "ETH_Ledger_Private_Key",
   "ETH_MEW_Address", "ETH_MEW_Public_Key", "ETH_MEW_Private_Key",
   "ETH_TRUST_Address", "ETH_TRUST_Public_Key", "ETH_TRUST_Private_Key",
   "ETH_Legacy_Address", "ETH_Legacy_Public_Key", "ETH_Legacy_Private_Key"
]

def parse_line(line, keys):
   """
   Use a regex per key to capture its value (even with spaces) from the single line.
   The pattern captures from "key:" up until the next " key:" or end-of-line.
   """
   parts = {}
   for key in keys:
       pattern = re.escape(key) + r':(.*?)(?=\s+\S+?:|$)'
       match = re.search(pattern, line)
       if match:
           parts[key] = match.group(1).strip()
   return parts

def process_and_split_files(input_folder, sorted_folder):
   """
   Process each .txt file individually. For each file, expand the single input line into multiple
   formatted lines exactly as specified, and save the output to a new file.
   """
   try:
       # Find all .txt files in the input folder (including subfolders)
       text_files = [
           os.path.join(root, file)
           for root, _, files in os.walk(input_folder)
           for file in files if file.endswith(".txt")
       ]
       print(f"[INFO] Found {len(text_files)} text files to process.")

       next_file_number = get_next_file_number()

       for input_file in text_files:
           expanded_lines = []
           print(f"[PROCESSING] Reading file: {input_file}")

           # Skip empty files
           if os.stat(input_file).st_size == 0:
               print(f"[INFO] Skipping empty file: {input_file}")
               continue

           with open(input_file, 'r', encoding='utf-8') as f:
               for line in f:
                   line = line.strip()
                   parts = parse_line(line, expected_keys)
                   if all(key in parts for key in expected_keys):
                       # Expand the single line into multiple output lines exactly as specified.
                       expanded_lines.extend([
                           f"wallet_address:{parts['BTC_P2WPKH']} private_key:{parts['Key_Hex']} CompressedPubKey:{parts['BTC_CompPub']}",
                           f"wallet_address:{parts['BTC_P2WSH_Multisig']} private_key:{parts['Key_Hex']} CompressedPubKey:{parts['BTC_CompPub']} Private_Key2:{parts['BTC_Multisig_Key2']} Private_Key3:{parts['BTC_Multisig_Key3']} Script:{parts['BTC_Multisig_Script']}",
                           f"wallet_address:{parts['BTC_P2TR']} private_key:{parts['Key_Hex']} CompressedPubKey:{parts['BTC_CompPub']} Taproot_Key:{parts['BTC_TaprootKey']}",
                           f"wallet_address:{parts['BTC_Legacy_Address']} private_key:{parts['BTC_Legacy_Key']} HexKey:{parts['Key_Hex']}",
                           f"wallet_address:{parts['BTC_P2SH_Address']} private_key:{parts['BTC_P2SH_Key']} HexKey:{parts['Key_Hex']}",
                           f"wallet_address:{parts['XRP_ed25519_Classic_Address']} private_key:{parts['XRP_ed25519_Private_Key']} xrpED_XAddress:{parts['XRP_ed25519_X-Address']} xrpED_seed:{parts['XRP_ed25519_Seed']} xrpED_Public_Key:{parts['XRP_ed25519_Public_Key']} HexKey:{parts['Key_Hex']}",
                           f"wallet_address:{parts['XRP_secp256k1_Classic_Address']} private_key:{parts['XRP_secp256k1_Private_Key']} xrpSECP_X_Address:{parts['XRP_secp256k1_X-Address']} xrpSECP_seed:{parts['XRP_secp256k1_Seed']} xrpSECP_Public_Key:{parts['XRP_secp256k1_Public_Key']} HexKey:{parts['Key_Hex']}",
                           f"wallet_address:{parts['DOGE_Address']} private_key:{parts['DOGE_WIF']} DOGE_Public_Key:{parts['DOGE_Public_Key']} Doge_Priv_Key:{parts['DOGE_Private_Key']}",
                           f"wallet_address:{parts['SOL_Address']} private_key:{parts['SOL_Private_Key']} SOL_Derivation:{parts['SOL_Derivation']} SOL_seed:{parts['SOL_Seed']} SOL_Public_Key:{parts['SOL_Public_Key']} SOL_Mnemonic:{parts['Mnemonic_ALL']} HexKey:{parts['Key_Hex']}",
                           f"wallet_address:{parts['CARD_Payment_Address']} private_key:{parts['CARD_Payment_SKey_Hex']} CARD_Verification_HEX:{parts['CARD_Payment_VKey_Hex']} CARD_Stake_SKey:{parts['CARD_Stake_SKey_Hex']} CARD_Stake_VKey:{parts['CARD_Stake_VKey_Hex']} CARD_Mnemonic:{parts['Mnemonic_ALL']} HexKey:{parts['Key_Hex']}",
                           f"wallet_address:{parts['ETH_Standard_Address']} private_key:{parts['ETH_Standard_Private_Key']} ETH_seed_Bytes:{parts['ETH_Seed_Bytes']} ETH_Public_Key:{parts['ETH_Standard_Public_Key']} ETH_Mnemonic:{parts['Mnemonic_ALL']} HexKey:{parts['Key_Hex']}",
                           f"wallet_address:{parts['ETH_Ledger_Address']} private_key:{parts['ETH_Ledger_Private_Key']} ETH_seed_Bytes:{parts['ETH_Seed_Bytes']} ETH_Public_Key:{parts['ETH_Ledger_Public_Key']} ETH_Mnemonic:{parts['Mnemonic_ALL']} HexKey:{parts['Key_Hex']}",
                           f"wallet_address:{parts['ETH_MEW_Address']} private_key:{parts['ETH_MEW_Private_Key']} ETH_seed_Bytes:{parts['ETH_Seed_Bytes']} ETH_Public_Key:{parts['ETH_MEW_Public_Key']} ETH_Mnemonic:{parts['Mnemonic_ALL']} HexKey:{parts['Key_Hex']}",
                           f"wallet_address:{parts['ETH_TRUST_Address']} private_key:{parts['ETH_TRUST_Private_Key']} ETH_seed_Bytes:{parts['ETH_Seed_Bytes']} ETH_Public_Key:{parts['ETH_TRUST_Public_Key']} ETH_Mnemonic:{parts['Mnemonic_ALL']} HexKey:{parts['Key_Hex']}",
                           f"wallet_address:{parts['ETH_Legacy_Address']} private_key:{parts['ETH_Legacy_Private_Key']} ETH_seed_Bytes:{parts['ETH_Seed_Bytes']} ETH_Public_Key:{parts['ETH_Legacy_Public_Key']} ETH_Mnemonic:{parts['Mnemonic_ALL']} HexKey:{parts['Key_Hex']}",
                       ])
                   else:
                       print(f"[WARNING] Not all keys found in line: {line}")

           # Write the expanded lines to an output file (one file per input file)
           output_file = os.path.join(sorted_folder, f"sorted_file_{next_file_number}.txt")
           with open(output_file, 'w', encoding='utf-8') as f:
               f.write("\n".join(expanded_lines) + "\n")
           print(f"[INFO] Saved output file: {output_file}")
           next_file_number += 1

       update_log_file(next_file_number - 1)
       print("[INFO] All files processed successfully.")

   except Exception as e:
       print(f"[ERROR] An error occurred: {e}")

# Run the script
process_and_split_files(input_folder, sorted_folder)
 

HYM3DatabaseLoader.py

This loads all on an external hard drive and deletes from sorted source and is further sorted an organized for instant searches. Generated keys in original folder must be manually deleted. Do not delete log or recovery files. These keep track of what has been completed.  

import os
import gc  # Import the garbage collector

# === CONFIGURATION ===
INPUT_FOLDER = r"c:\HYM3CryptoTools\Sorted\Total"  # Folder with input files
OUTPUT_FOLDER = r"e:\search"     # Base folder for output
KEYWORD_START = "wallet_address:"
KEYWORD_MID = "private_key:"

def create_nested_directory(base, identifier):
   """
   Create a nested directory structure using the first 20 characters of the identifier.
   Each character becomes one subfolder level.
   """
   nested_path = base
   for ch in identifier[:20]:
       nested_path = os.path.join(nested_path, ch)
   os.makedirs(nested_path, exist_ok=True)
   return nested_path

def process_file(input_file, output_folder):
   """
   Process a single input file. Each line is expected to contain:
      "wallet_address:" + identifier + " " + "private_key:" + content...
   The identifier (the part between wallet_address: and private_key:) is used as the new file name.
   The output file content is everything from "private_key:" onward, preserving all tokens 
   (such as "Verifications", "scripts", "mnemonics", etc.).
   """
   print(f"[INFO] Processing: {input_file}")
   with open(input_file, 'r', encoding='utf-8') as f:
       for line in f:
           line = line.strip()
           if not line:
               continue

           # Find positions of the keywords
           pos_start = line.find(KEYWORD_START)
           pos_mid = line.find(KEYWORD_MID)
           if pos_start == -1 or pos_mid == -1:
               print(f"[WARNING] Line missing required keywords: {line}")
               continue

           # Extract identifier between "address:" and "information:"; trim any extra spaces.
           identifier = line[len(KEYWORD_START):pos_mid].strip()
           if not identifier:
               print(f"[WARNING] No identifier found in line: {line}")
               continue

           # Extract file content: starting from "information:" (keeping it and everything after)
           content = line[pos_mid:].lstrip()

           # Create nested directory based on the first 20 characters of the identifier
           nested_folder = create_nested_directory(output_folder, identifier)
           # Build the file path using the identifier as the file name
           file_path = os.path.join(nested_folder, identifier + ".txt")
           
           # Write the content to the file
           with open(file_path, 'w', encoding='utf-8') as out_f:
               out_f.write(content)
           print(f"[INFO] Saved file: {file_path}")

   # Delete the input file after processing
   try:
       os.remove(input_file)
       print(f"[INFO] Deleted input file: {input_file}")
   except Exception as e:
       print(f"[ERROR] Could not delete file {input_file}: {e}")

   # Clear memory after processing this file
   gc.collect()

def process_all_files(input_folder, output_folder):
   """
   Process all .txt files in the input folder and its subfolders.
   """
   text_files = [
       os.path.join(root, file)
       for root, _, files in os.walk(input_folder)
       for file in files if file.endswith(".txt")
   ]

   if not text_files:
       print("[INFO] No files found to process.")
       return

   print(f"[INFO] Found {len(text_files)} files to process.")
   for input_file in text_files:
       process_file(input_file, output_folder)
       # Clear memory after processing each file
       gc.collect()

# === MAIN EXECUTION ===
if __name__ == "__main__":
   print(f"[INFO] Starting processing from {INPUT_FOLDER} to {OUTPUT_FOLDER}")
   process_all_files(INPUT_FOLDER, OUTPUT_FOLDER)
   print("[INFO] Processing completed.")

HYM3Search.py

Script allows instantly searching the External Hard Drive for any Address Matches.  

import os

OUTPUT_FOLDER = r"e:\Search"

def build_file_path(identifier):
   """
   Build the nested directory path and expected file name based on the first 20 characters
   of the identifier. Each of the first 20 characters creates one subfolder level.
   """
   nested_folder = OUTPUT_FOLDER
   for ch in identifier[:20]:
       nested_folder = os.path.join(nested_folder, ch)
   file_name = identifier + ".txt"
   return nested_folder, file_name

def main():
   while True:
       identifier = input("Enter the identifier (min 20 characters, or type 'exit' to quit): ").strip()
       if identifier.lower() == "exit":
           break
       if len(identifier) < 20:
           print("Identifier must be at least 20 characters long.")
           continue

       nested_folder, file_name = build_file_path(identifier)
       file_path = os.path.join(nested_folder, file_name)

       # Check if the folder exists, then verify an exact file name match.
       if not os.path.exists(nested_folder):
           print("No match found.")
           continue

       try:
           files_in_folder = os.listdir(nested_folder)
       except Exception as e:
           print(f"Error accessing directory: {e}")
           continue

       if file_name not in files_in_folder:
           print("No match found.")
           continue

       try:
           with open(file_path, 'r', encoding='utf-8') as f:
               print(f"\nFile found: {file_path}")
               print("Contents:")
               print(f.read())
       except Exception as e:
           print(f"Error reading file: {e}")

if __name__ == "__main__":
   main()