import time
import itertools
from multiprocessing import Pool, cpu_count
import hashlib, struct, base58
from ecdsa import SigningKey, SECP256k1

# === Configuration ===
TARGET_ADDRESS = "1ATUAMkg2y9mFB2fEJCmovt53bsgaiG5Ug"

# breathe black tower truth food liberty moon mask subject proof vote real
position_words = {
    1:  ["food","this", "subject", "breathe", "black", "order", "vote"],
    2:  ["food","this", "subject", "real", "black", "order", "vote"],
    3:  ["food","this", "subject", "breathe", "tower", "order", "vote"],
    4:  ["truth"],
    5:  ["food","this", "subject", "real", "black", "order", "vote"],
    6:  ["liberty"],
    7:  ["moon"],
    8:  ["food","this", "subject", "mask", "black", "order", "vote"],
    9:  ["food","this", "subject", "real", "black", "order", "vote"],
    10: ["food","this", "subject", "real", "black", "order", "proof"],
    11: ["food","this", "subject", "real", "black", "order", "vote"],
    12: ["food","this", "subject", "real", "black", "order", "vote"]
}


REPORT_INTERVAL = 5  # seconds


# === Private key to P2PKH address ===
def private_to_address(priv):
    sk = SigningKey.from_string(priv, curve=SECP256k1)
    pub = b'\x04' + sk.verifying_key.to_string()
    sha = hashlib.sha256(pub).digest()
    ripe = hashlib.new('ripemd160', sha).digest()
    prefixed = b'\x00' + ripe
    checksum = hashlib.sha256(hashlib.sha256(prefixed).digest()).digest()[:4]
    return base58.b58encode(prefixed + checksum).decode()

# === Electrum v1 seed to address ===
def electrum_seed_to_addr(seed_words):
    phrase = ' '.join(seed_words)
    seed = hashlib.sha512(phrase.encode('utf-8')).digest()
    priv_key = seed[:32]
    return private_to_address(priv_key)

# === Combination checker ===
def check_combination(combo):
    if len(set(combo)) < len(combo):  # enforce unique words
        return None
    try:
        address = electrum_seed_to_addr(combo)
        if address == TARGET_ADDRESS:
            return combo
    except:
        return None
    return None

# === Parallel combination scanner ===
def scan_combinations_parallel():
    word_lists = [position_words[i + 1] for i in range(12)]
    total = 1
    for lst in word_lists:
        total *= len(lst)

    print(f"Scanning {total:,} Electrum v1 seed combinations using {cpu_count()} cores...")

    start = time.time()
    last_report = start
    pool = Pool(cpu_count())

    generator = itertools.product(*word_lists)

    for i, result in enumerate(pool.imap_unordered(check_combination, generator, chunksize=1000)):
        now = time.time()
        if now - last_report >= REPORT_INTERVAL:
            elapsed = now - start
            speed = i / elapsed
            progress = (i / total) * 100
            print(f"[{elapsed:.1f}s] Checked: {i:,} | Speed: {speed:,.0f}/s | Progress: {progress:.6f}%")
            last_report = now

        if result:
            print("\nSUCCESS! Valid Electrum seed found:")
            print(" ".join(result))
            print(f"Address: {TARGET_ADDRESS}")
            pool.terminate()
            return

    print("\nDone. No matching Electrum-style mnemonic found.")

# === Main ===
if __name__ == "__main__":
    scan_combinations_parallel()

import itertools
import time
from multiprocessing import Pool, cpu_count
from mnemonic import Mnemonic
from Crypto.Hash import HMAC, SHA512
import hashlib, struct, base58
from ecdsa import SigningKey, SECP256k1

TARGET_ADDRESS = "1KfZGvwZxsvSmemoCmEV75uqcNzYBHjkHZ"
REPORT_INTERVAL = 3  # seconds
mnemo = Mnemonic('english')

# Position-specific word candidates
position_words = {
    1: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],
    2: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],
    3: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],
    4: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],
    5: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],
    6: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],],
    7: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],,
    8: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],,
    9: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],
    10: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],
    11:["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],
    12: ["black", "this", "day", "subject", "food", "real", "liberty", "time",
        "proof", "receive", "tower", "moon", "order", "police", "change",
        "vote", "future", "world", "mask"],

def hmac_sha512(key, data):
    return HMAC.new(key, data, digestmod=SHA512).digest()

def derive_bip44_key(seed):
    hardened = 0x80000000
    key = b'Bitcoin seed'
    I = hmac_sha512(key, seed)
    priv_key, chain = I[:32], I[32:]
    for index in [44 + hardened, 0 + hardened, 0 + hardened, 0, 0]:
        data = b'\x00' + priv_key + struct.pack('>L', index)
        I = hmac_sha512(chain, data)
        priv_key, chain = I[:32], I[32:]
    return priv_key

def private_to_address(priv):
    sk = SigningKey.from_string(priv, curve=SECP256k1)
    pub = b'\x04' + sk.verifying_key.to_string()
    sha = hashlib.sha256(pub).digest()
    ripe = hashlib.new('ripemd160', sha).digest()
    prefixed = b'\x00' + ripe
    checksum = hashlib.sha256(hashlib.sha256(prefixed).digest()).digest()[:4]
    return base58.b58encode(prefixed + checksum).decode()

def bip39_seed_to_addr(seed_words):
    phrase = ' '.join(seed_words)
    seed = mnemo.to_seed(phrase, passphrase="")
    priv = derive_bip44_key(seed)
    return private_to_address(priv)

def check_combination(combo):
    # Reject combinations with duplicate words
    if len(set(combo)) < len(combo):
        return None

    phrase = ' '.join(combo)
    if not mnemo.check(phrase):
        return None

    try:
        address = bip39_seed_to_addr(combo)
        if address == TARGET_ADDRESS:
            return combo
    except Exception:
        return None

    return None

def scan_positional_combinations():
    all_combinations = itertools.product(
        position_words[1], position_words[2], position_words[3],
        position_words[4], position_words[5], position_words[6],
        position_words[7], position_words[8], position_words[9],
        position_words[10], position_words[11], position_words[12]
    )
    total = 6**12
    print(f"Scanning {total:,} combinations using {cpu_count()} cores...")

    start = time.time()
    last_report = start
    pool = Pool(cpu_count())

    for i, result in enumerate(pool.imap_unordered(check_combination, all_combinations, chunksize=100)):
        now = time.time()
        if now - last_report >= REPORT_INTERVAL:
            elapsed = now - start
            speed = i / elapsed
            progress = (i / total) * 100
            print(f"[{elapsed:.1f}s] Checked: {i:,} | Speed: {speed:,.0f}/s | Progress: {progress:.8f}%")
            last_report = now

        if result:
            print("\nSUCCESS! Valid mnemonic found:")
            print(" ".join(result))
            print(f"Address: {TARGET_ADDRESS}")
            pool.terminate()
            return

    print("\nDone. No matching mnemonic found.")

if __name__ == "__main__":
    scan_positional_combinations()

// gpu_scan_secp256k1_full.cu
// Full GPU-based secp256k1 -> SHA256 -> RIPEMD160 scanner using actual CUDA ECC and hash implementations
// Dependencies: secp256k1.cuh, sha256.cuh, ripemd160.cuh, ptx.cuh

#include <stdio.h>
#include <stdint.h>
#include <cuda.h>
#include <cuda_runtime.h>

#include "secp256k1.cuh"
#include "sha256.cuh"
#include "ripemd160.cuh"
#include "ptx.cuh"

__device__ bool check_prefix(const uint8_t* h160) {
    return h160[0] == 0xf6 && h160[1] == 0xf5 && h160[2] == 0x43;
}

__global__ void kernel_scan(uint64_t base, uint64_t total_keys) {
    uint64_t idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx >= total_keys) return;

    uint64_t priv = base + idx;

    uint256_t seckey;
    set_uint256_from_uint64(seckey, priv);

    secp256k1_pubkey_t pubkey;
    secp256k1_scalar_multiply(pubkey, seckey);

    uint8_t pubkey33[33];
    secp256k1_compress_pubkey(pubkey33, pubkey);

    uint8_t sha_digest[32];
    sha256(pubkey33, 33, sha_digest);

    uint8_t h160[20];
    ripemd160(sha_digest, 32, h160);

    if (check_prefix(h160)) {
        printf("[MATCH] priv=0x%016llx h160=%.2x%.2x%.2x...\n",
               (unsigned long long)priv, h160[0], h160[1], h160[2]);
    }
}

int main(int argc, char** argv) {
    if (argc != 4) {
        printf("Usage: ./gpu_scan <start> <count> <threads_per_block>\n");
        return 1;
    }

    uint64_t start = strtoull(argv[1], nullptr, 0);
    uint64_t count = strtoull(argv[2], nullptr, 0);
    int threads = atoi(argv[3]);

    uint64_t blocks = (count + threads - 1) / threads;

    cudaEvent_t t_start, t_end;
    cudaEventCreate(&t_start);
    cudaEventCreate(&t_end);
    cudaEventRecord(t_start);

    kernel_scan<<<blocks, threads>>>(start, count);
    cudaDeviceSynchronize();

    cudaEventRecord(t_end);
    cudaEventSynchronize(t_end);

    float ms = 0;
    cudaEventElapsedTime(&ms, t_start, t_end);
    printf("\nScanned %llu keys in %.2f s (%.2f MH/s)\n",
           (unsigned long long)count, ms / 1000.0, count / (ms * 1e3));

    return 0;
}