Bitcoin puzzle transaction ~32 BTC prize to who solves it

[nomachine]

i need speed.

My brute force Rust script with "use rand_chacha::ChaCha20Rng"

# time ./puzzle -p 40 -a 1EeAxcprB2PpCnr34VfZdFrkUWuxyiNEFv

• Puzzle search
• Script started at:2024-09-22 14:36:57
• concurrency:12
• range:549755813888 to:1099511627775
• target:1EeAxcprB2PpCnr34VfZdFrkUWuxyiNEFv
• --------------------------------------------------------------------------------
• KEY FOUND! 2024-09-22 14:41:06
• decimal: 1003651412950
• private key: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9aFJuCJDo5F6Jm7
• public key: 03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4
• address: 1EeAxcprB2PpCnr34VfZdFrkUWuxyiNEFv
• --------------------------------------------------------------------------------

real   4m9.203s
user   11m5.293s
sys   0m0.276s

look
https://bitcointalk.org/index.php?topic=1306983.msg64301108#msg64301108

It cannot be faster than this in random mode on my PC.

p.s.
There are various types of RNGs in Rust, each with its own set of trade-offs and speed.

Here is a list:

https://rust-random.github.io/book/guide-rngs.html

You need Nvme & motherboard fast as hell to go 8 GB/s

[Tepan]

can the code has parameter to setup ranges with decimal ? even though is random, i want it like random through ranges.

[Kelvin555]

My brute force Rust script with "use rand_chacha::ChaCha20Rng"

I have a Rust code, can you help me optimize it ?

[Marcel.]

It makes my day every time an intended troll post or unintended wrong statement results in some flame war 

My bad... haven't slept much and i've must've seen something else on the time stamp and hurried to post what i've "found"  )
Sorry 'bout the fake news

[CryptoNoob1]

Hi Guys, Lets say I have the key for puzzle 68 already , How can I spend it safely as I have seen what happned with puzzle 65 , Please can someone help will tip

[nomachine]

can the code has parameter to setup ranges with decimal ? even though is random, i want it like random through ranges.

Yes.

I have a Rust code, can you help me optimize it ?

This code is with fast 7 GB/s SmallRng and ranges with decimal

main.rs

Code:

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<String>,
    found_flag: &Arc<AtomicBool>,
    _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;
        }
    }
}

Cargo.toml

Code:

[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"

cargo build --release --target=x86_64-unknown-linux-gnu


 # ./puzzle -r 1020000000:1040000000 -a 1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps

• Puzzle search
• Script started at:2024-09-22 18:25:34
• concurrency:12
• range:1020000000 to:1040000000
• target:1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps
• --------------------------------------------------------------------------------
• KEY FOUND! 2024-09-22 18:25:54
• decimal: 1033162084
• private key: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M8diLSC5MyERoW
• public key: 030d282cf2ff536d2c42f105d0b8588821a915dc3f9a05bd98bb23af67a2e92a5b
• address: 1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps
• --------------------------------------------------------------------------------

# ./puzzle -r 46346217550300000000:46346217550360000000 -a 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

• Puzzle search
• Script started at:2024-09-22 19:05:32
• concurrency:12
• range:46346217550300000000 to:46346217550360000000
• target:13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
• --------------------------------------------------------------------------------
• KEY FOUND! 2024-09-22 19:06:00
• decimal: 46346217550346335726
• private key: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZfFoWMiwBt943V7CQeX
• public key: 024ee2be2d4e9f92d2f5a4a03058617dc45befe22938feed5b7a6b7282dd74cbdd
• address: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

And this is an example of how narrow the range must be to hit WIF.

[mcdouglasx]

Hi Guys, Lets say I have the key for puzzle 68 already , How can I spend it safely as I have seen what happned with puzzle 65 , Please can someone help will tip

Use https://slipstream.mara.com/

[AlanJohnson]

# ./puzzle -r 46346217550300000000:46346217550360000000 -a 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

• Puzzle search
• Script started at:2024-09-22 19:05:32
• concurrency:12
• range:46346217550300000000 to:46346217550360000000
• target:13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
• --------------------------------------------------------------------------------
• KEY FOUND! 2024-09-22 19:06:00
• decimal: 46346217550346335726
• private key: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZfFoWMiwBt943V7CQeX
• public key: 024ee2be2d4e9f92d2f5a4a03058617dc45befe22938feed5b7a6b7282dd74cbdd
• address: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

And this is an example of how narrow the range must be to hit WIF.

You hit the WIF in less than a minute... but if you have more time the range can be larger right ?

I tested your program and it works fine... i was wondering if that would make any sense to compile it for windows and run it on 5W powered fanless Intel NUC  1core atom procesor and let it run "forever" as a lottery ...

[ihsotas91]

Hi Guys, Lets say I have the key for puzzle 68 already , How can I spend it safely as I have seen what happned with puzzle 65 , Please can someone help will tip

what happened with puzzle 65?

[nomachine]

I tested your program and it works fine... i was wondering if that would make any sense to compile it for windows and run it on 5W powered fanless Intel NUC  1core atom procesor and let it run "forever" as a lottery ...

It doesn't have to be forever... I have a crystal ball, but I don't know how to look into it. 

[COBRAS]

I tested your program and it works fine... i was wondering if that would make any sense to compile it for windows and run it on 5W powered fanless Intel NUC  1core atom procesor and let it run "forever" as a lottery ...

It doesn't have to be forever... I have a crystal ball, but I don't know how to look into it.  

Hi, bro.


Did you know how to randomly  generate this sequence with random nambers from I 39 to 2 , faster is posible ?

Sequence,all next member of sequence < the previous ?

39 38 37 32 31 30 28 27 24 22 21 15 12 11 9 7 6

thank you

[citb0in]

I may have missed this, but is there a working Kangaroo on github that can handle more than 128bit and is guaranteed to work correctly?

[digitalbear]

https://privatekeys.pw/address/bitcoin/1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9

For other addresses you can check using hash:

Public Key Hash (Hash 160):
739437bb3dd6d1983e66629c5f08c70e52769371

Based on the puzzle's statistics, the private key for 67 is likely around 95XXXXXX. If anyone finds it within this range, I’d be more than happy to accept some gifts!

bc1q4xj4maw4csvn084zwjtrgzg8tk08660mxj6wnw

It is not working to find the other addresses using the hash: https://privatekeys.pw/quick-search?query=739437bb3dd6d1983e66629c5f08c70e52769371
it is searching only using the HEX or brainwallet

[nomachine]

Did you know how to randomly  generate this sequence with random nambers from I 39 to 2 , faster is posible ?

Sequence,all next member of sequence < the previous ?

39 38 37 32 31 30 28 27 24 22 21 15 12 11 9 7 6

thank you

Code:

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)

[Tepan]

Guys,
Puzzle 62 has private key, and that private key can used for answer for 66 bit.

i can't explain, but i found something funny while doing something with decimal number on that upper range.

[COBRAS]

Did you know how to randomly  generate this sequence with random nambers from I 39 to 2 , faster is posible ?

Sequence,all next member of sequence < the previous ?

39 38 37 32 31 30 28 27 24 22 21 15 12 11 9 7 6

thank you

Code:

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)

Bro, thank you very mach.Worked, faster theny scrypt, but, no so fast.


Bro, can you make example of a scrypt with your super fast RNG generator on rust ?

please

numbers from 39 to 6.

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

?

ps in python I get only 50000 examples every 3 seconds:

Code:

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)

[37, 36, 35, 34, 33, 30, 28, 27, 22, 20, 15, 14, 13, 9, 8, 7, 6] 2000000
[38, 34, 33, 31, 30, 28, 27, 26, 25, 24, 22, 16, 13, 12, 10, 7, 6] 2050000
[39, 35, 34, 33, 31, 29, 28, 27, 23, 22, 20, 19, 17, 13, 12, 11, 6] 2100000
[38, 37, 35, 34, 32, 31, 26, 25, 24, 23, 22, 21, 18, 15, 14, 11, 6] 2150000
[38, 37, 36, 33, 32, 29, 27, 26, 24, 23, 22, 21, 20, 18, 14, 8, 6] 2200000
[36, 32, 31, 30, 29, 28, 26, 25, 22, 18, 17, 15, 13, 10, 9, 8, 6] 2250000
[38, 36, 32, 31, 30, 28, 27, 26, 25, 23, 21, 20, 19, 17, 13, 9, 8] 2300000

[Tepan]

trying, scaled the decimal to get the range of hex key.


root@C.######:~/keyhunt$ ./keyhunt -m rmd160 -f 66.rmd -r 2832c39f97c496000:2833a1c9e61552000 -n 0x1000000000 -k 256 -l compress -s 1 -t 128

• Version 0.2.230519 Satoshi Quest, developed by AlbertoBSD
• Mode rmd160
• K factor 256
• Search compress only
• Stats output every 1 seconds
• Threads : 128
• N = 0x1000000000
• Range
• -- from : 0x2832c39f97c496000
• -- to   : 0x2833a1c9e61552000
• Allocating memory for 1 elements: 0.00 MB
• Bloom filter for 1 elements.
• Loading data to the bloomfilter total: 0.03 MB
• Sorting data ... done! 1 values were loaded and sorted
• Total 11198087168 keys in 339 seconds: ~33 Mkeys/s (33032705 keys/s)

 

i try, it took 140 days to done with this, if you have 10K Mkeys, it will be done in less than one day.

[COBRAS]

trying, scaled the decimal to get the range of hex key.


root@C.######:~/keyhunt$ ./keyhunt -m rmd160 -f 66.rmd -r 2832c39f97c496000:2833a1c9e61552000 -n 0x1000000000 -k 256 -l compress -s 1 -t 128

• Version 0.2.230519 Satoshi Quest, developed by AlbertoBSD
• Mode rmd160
• K factor 256
• Search compress only
• Stats output every 1 seconds
• Threads : 128
• N = 0x1000000000
• Range
• -- from : 0x2832c39f97c496000
• -- to   : 0x2833a1c9e61552000
• Allocating memory for 1 elements: 0.00 MB
• Bloom filter for 1 elements.
• Loading data to the bloomfilter total: 0.03 MB
• Sorting data ... done! 1 values were loaded and sorted
• Total 11198087168 keys in 339 seconds: ~33 Mkeys/s (33032705 keys/s)

 

i try, it took 140 days to done with this, if you have 10K Mkeys, it will be done in less than one day.

you try konvertr range to wif and solve with scrypt of nomachine ? because this spped is slower then .dat password brute )))

because:

range:46346217550300000000 to:46346217550360000000
target:13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

1 min to search

[Tepan]

 # ./puzzle -r 1020000000:1040000000 -a 1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps

• Puzzle search
• Script started at:2024-09-22 18:25:34
• concurrency:12
• range:1020000000 to:1040000000
• target:1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps
• --------------------------------------------------------------------------------
• KEY FOUND! 2024-09-22 18:25:54
• decimal: 1033162084
• private key: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M8diLSC5MyERoW
• public key: 030d282cf2ff536d2c42f105d0b8588821a915dc3f9a05bd98bb23af67a2e92a5b
• address: 1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps
• --------------------------------------------------------------------------------

# ./puzzle -r 46346217550300000000:46346217550360000000 -a 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

• Puzzle search
• Script started at:2024-09-22 19:05:32
• concurrency:12
• range:46346217550300000000 to:46346217550360000000
• target:13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
• --------------------------------------------------------------------------------
• KEY FOUND! 2024-09-22 19:06:00
• decimal: 46346217550346335726
• private key: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZfFoWMiwBt943V7CQeX
• public key: 024ee2be2d4e9f92d2f5a4a03058617dc45befe22938feed5b7a6b7282dd74cbdd
• address: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

And this is an example of how narrow the range must be to hit WIF.

root@C.######:~/puzzle_solver$ cargo run -- --address 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so --range 0x2832c39f97c496000:0x2833a1c9e61552000
   Compiling puzzle v0.2.0 (/root/puzzle_solver)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.15s
     Running `target/debug/puzzle --address 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so --range '0x2832c39f97c496000:0x2833a1c9e61552000'`

• Puzzle search
• Script started at:2024-09-23 00:22:48
• Thread:124
• range:46345481609057755136 to:46349389981600260096
• target:13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
• --------------------------------------------------------------------------------
• 2024-09-23 00:23:00
• decimal: 46349075931177856298
• private key: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZfFzd1mcPdvDRum7nYS
• public key: 0288e98e6327376050c6789417ec200454b5730955389bc782868dfe0698eff2a3
• address: 13zb1vySc4RTXfMcSqvBv8hhMSEhY4viFi
• --------------------------------------------------------------------------------

I'm trying to test with already found #66

Good!, I'll try something, if i hit something, i'l message you bro , wish me luck.

[Tepan]

I have range of exactly the range of #67, but i have less resource of bruteforce software/hardware.

I use math, and i have proof to clarify it's work.