Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 42. (Read 230559 times)

import random as A

tri = [39, 38, 37, 32, 31, 30, 28, 27, 24, 22, 21, 15, 12, 11, 9, 7, 6]

B=list(range(39,5,-1))

C =[]
count = 0

while tri != C:
    count=count+1
    C=A.sample(B,k=A.randint(17,17))
    C.sort(reverse=True);
   
    if count % 50000 ==0:
        print(C,count)

import random as A
B=list(range(39,1,-1));C=A.sample(B,k=A.randint(1,len(B)))
C.sort(reverse=True);print(C)

use bitcoin::address::Address;
use bitcoin::key::PrivateKey;
use bitcoin::network::NetworkKind;
use chrono::Local;
use clap::{App, Arg};
use hex;
use num::bigint::BigInt;
use num::traits::One;

use num_cpus;
use rand::Rng;
use rand::rngs::SmallRng;
use rand::SeedableRng;
use std::fs::File;
use std::io::{self, Write};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc};
use std::convert::TryInto;
use threadpool::ThreadPool;

fn main() {
    // Print the current time when the script starts
    let current_time = Local::now();
    println!(
        "\x1b[38;5;226m[+] Puzzle search\n[+] Script started at:{}",
        current_time.format("%Y-%m-%d %H:%M:%S")
    );
    
    let matches = App::new("Puzzle Solver")
        .version("1.0")
        .arg(
            Arg::with_name("puzzle")
                .short('p')
                .long("puzzle")
                .value_name("PUZZLE")
                .help("Sets the puzzle number")
                .takes_value(true),  // No longer required
        )
        .arg(
            Arg::with_name("address")
                .short('a')
                .long("address")
                .value_name("ADDRESS")
                .help("Sets the target address")
                .required(true)
                .takes_value(true),
        )
        .arg(
            Arg::with_name("range")
                .short('r')
                .long("range")
                .value_name("RANGE")
                .help("Sets the search range in decimal format (e.g. 73786976294838206464:147573952589676412927)")
                .takes_value(true),
        )
        .get_matches();

    let puzzle_str = matches.value_of("puzzle");
    let range_str = matches.value_of("range");

    // Ensure either -p or -r is provided
    if puzzle_str.is_none() && range_str.is_none() {
        panic!("Either --puzzle (-p) or --range (-r) must be provided.");
    }

    let target_address = Arc::new(matches
        .value_of("address")
        .expect("Target address is required")
        .to_string());

    // Parse the range if -r is provided; otherwise calculate it based on the puzzle number
    let (range_start, range_end): (BigInt, BigInt) = if let Some(range_str) = range_str {
        let parts: Vec<&str> = range_str.split(':').collect();
        if parts.len() != 2 {
            panic!("Invalid range format. Expected format: start:end");
        }
        let range_start = BigInt::parse_bytes(parts[0].as_bytes(), 10)
            .expect("Failed to parse range start");
        let range_end = BigInt::parse_bytes(parts[1].as_bytes(), 10)
            .expect("Failed to parse range end");
        (range_start, range_end)
    } else {
        // If no range is provided, compute the range from the puzzle number
        let puzzle: u128 = puzzle_str.unwrap().parse().expect("Failed to parse puzzle number");
        let range_start: BigInt = num::pow(BigInt::from(2), (puzzle - 1) as usize);
        let range_end: BigInt = num::pow(BigInt::from(2), puzzle as usize) - BigInt::one();
        (range_start, range_end)
    };

    let num_threads = num_cpus::get() as usize; // Convert to usize

    println!(
        "[+] concurrency:{}\n[+] range:{} to:{}\n[+] target:{}",
        num_threads, range_start, range_end, target_address
    );

    let found_flag = Arc::new(AtomicBool::new(false));
    let pool = ThreadPool::new(num_threads.try_into().unwrap()); // Convert to usize

    // Handling termination signals
    let found_flag_clone = found_flag.clone();
    ctrlc::set_handler(move || {
        found_flag_clone.store(true, Ordering::Relaxed);
        std::process::exit(0); // Terminate the program
    })
    .expect("Error setting Ctrl-C handler");

    for _ in 0..num_threads {
        let target_address = Arc::clone(&target_address);
        let range_start_clone = range_start.clone();
        let range_end_clone = range_end.clone();
        let found_flag = found_flag.clone();
        let pool_clone = pool.clone();
        pool.execute(move || {
            let mut rng = SmallRng::from_entropy();
            random_lookfor(&rng.gen_range(range_start_clone.clone()..range_end_clone.clone()), &range_end_clone, &target_address, &found_flag, &pool_clone);
        });
    }

    pool.join();
}

fn random_lookfor(
    range_start: &BigInt,
    range_end: &BigInt,
    target_address: &Arc,
    found_flag: &Arc,
    _pool: &ThreadPool,
) {
    let mut rng = SmallRng::from_entropy();
    let secp = bitcoin::secp256k1::Secp256k1::new();

    loop {
        let key: BigInt = rng.gen_range(range_start.clone()..range_end.clone());
        let private_key_hex = format!("{:0>64x}", key);
        let private_key_bytes =
            hex::decode(&private_key_hex).expect("Failed to decode private key hex");

        let private_key = PrivateKey {
            compressed: true,
            network: NetworkKind::Main,
            inner: bitcoin::secp256k1::SecretKey::from_slice(&private_key_bytes)
                .expect("Failed to create secret key from slice"),
        };

        let public_key = private_key.public_key(&secp);
        let address = Address::p2pkh(&public_key, NetworkKind::Main).to_string();

        // Check if a match has been found by another thread
        if found_flag.load(Ordering::Relaxed) {
            break;
        }

        if address == **target_address {
            let current_time = Local::now();
            let line_of_dashes = "-".repeat(80);
            println!(
                "\n[+] {}\n[+] KEY FOUND! {}\n[+] decimal: {} \n[+] private key: {} \n[+] public key: {} \n[+] address: {}\n[+] {}",
                line_of_dashes,
                current_time.format("%Y-%m-%d %H:%M:%S"),
                key,
                private_key,
                public_key,
                address,
                line_of_dashes
            );

            // Set the flag to true to signal other threads to exit
            found_flag.store(true, Ordering::Relaxed);

            if let Ok(mut file) = File::create("KEYFOUNDKEYFOUND.txt") {
                let line_of_dashes = "-".repeat(130);
                writeln!(
                    &mut file,
                    "\n{}\nKEY FOUND! {}\ndecimal: {} \nprivate key: {} \npublic key: {} \naddress: {}\n{}",
                    line_of_dashes,
                    current_time.format("%Y-%m-%d %H:%M:%S"),
                    key,
                    private_key,
                    public_key,
                    address,
                    line_of_dashes
                )
                .expect("Failed to write to file");
            } else {
                eprintln!("Error: Failed to create or write to KEYFOUNDKEYFOUND.txt");
            }
            io::stdout().flush().unwrap();
            break;
        }
    }
}

[package]
name = "puzzle"
version = "0.2.0"
edition = "2021"

[dependencies]
num = "0.4.1"
num-traits = "0.2"
num-bigint = { version =  "0.4.6", features = ["rand"] }
threadpool = "1.8.1"    
bitcoin = "0.32.2"
hex = "0.4.3"
rand = { version = "0.8.5", features = ["small_rng"] }
secp256k1 = "0.29.1"
num_cpus = "1.16.0"
chrono = "0.4.38"
clap = "3.0"
ctrlc = "3.4.4"