Quote from: nomachine on January 22, 2024, 01:57:50 PM

Quote from: rosengold on January 21, 2024, 05:22:17 PM

share with us sir

I can share puzzle search app in Rust. I'm sick of code in Python. Grin

main.rs

Code:

extern crate bitcoin;
extern crate rand;
extern crate reqwest;
extern crate secp256k1;
extern crate num_cpus;
extern crate thousands;
extern crate threadpool;
extern crate chrono;

use bitcoin::network::Network;
use bitcoin::address::Address;
use bitcoin::key::PrivateKey;
use rand::Rng;
use std::env;
use std::fs::File;
use std::io::Write;
use std::sync::{Arc, Mutex};
use threadpool::ThreadPool;
use chrono::Local;

const TARGET: &str = "1QCbW9HWnwQWiQqVo5exhAnmfqKRrCRsvW";

fn main() {
// Print the current time when the script starts
let current_time = Local::now();
println!("[+] Puzzle search\n[+] Script started at: {}", current_time);

let args: Vec<String> = env::args().collect();
let num_threads = if args.len() < 2 {
num_cpus::get() as u32
} else {
args[1].parse().expect("Failed to parse number of threads")
};

let begin: u128 = 16383;
let end: u128 = 32767;

println!(
"[+] concurrency:{}\n[+] from:{} to:{}\n[+] target:{}",
num_threads,
begin,
end,
TARGET
);

let found_flag = Arc::new(Mutex::new(false));
let pool = ThreadPool::new(num_threads.try_into().unwrap());

for _ in 0..num_threads {
let pool = pool.clone();
let found_flag = found_flag.clone();
pool.execute(move || {
let mut rng = rand::thread_rng();
random_lookfor(rng.gen_range(begin..end), end, found_flag);
});
}

pool.join();
}

fn random_lookfor(begin: u128, end: u128, found_flag: Arc<Mutex<bool>>) {
let secp = bitcoin::secp256k1::Secp256k1::new();

loop {
let value: u128 = rand::thread_rng().gen_range(begin..end);
let private_key_hex = format!("{:0>64x}", value);
let private_key_bytes = hex::decode(&private_key_hex).expect("Failed to decode private key hex");

let private_key: PrivateKey = PrivateKey {
compressed: true,
network: Network::Bitcoin,
inner: bitcoin::secp256k1::SecretKey::from_slice(&private_key_bytes).unwrap(),
};

let public_key = private_key.public_key(&secp);
let address = Address::p2pkh(&public_key, Network::Bitcoin).to_string();
print!(
"\r[+] WIF: {}",
private_key
);

// Check if a match has been found by another thread
let mut found_flag = found_flag.lock().unwrap();
if *found_flag {
break;
}

if address == TARGET {
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,
value,
private_key,
public_key,
address,
line_of_dashes
);

// Set the flag to true to signal other threads to exit
*found_flag = true;

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,
value,
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");
}
break;
}
}
}

Cargo.toml

Code:

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

[dependencies]
threadpool = "1.8.0"
bitcoin_hashes = "0.13.0"
bitcoin = "0.31.1"
hex = "0.4.3"
rand = "0.8.5"
reqwest = "0.11.23"
secp256k1 = "0.28.1"
num_cpus = "1.16.0"
thousands = "0.2.0"
chrono = "0.4"

--------------------------------------------------------------------------------
KEY FOUND!
decimal: 26867
private key: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFY5iMZbuRxj
public key: 02fea58ffcf49566f6e9e9350cf5bca2861312f422966e8db16094beb14dc3df2c
address: 1QCbW9HWnwQWiQqVo5exhAnmfqKRrCRsvW
--------------------------------------------------------------------------------

Install Rust:

Code:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Configure Rust Environment:

Code:

source $HOME/.cargo/env

Code:

export PATH="$HOME/.cargo/bin:$PATH"

Create a Puzzle Rust Project:

Code:

cargo new puzzle

copy/paste above main.rs & Cargo.toml

Code:

cd puzzle

Build program

Code:

cargo build --release

Start

Code:

cargo run

or directly as a bin application

Code:

./target/release/puzzle

p.s.
You can remove :

Code:

print!(
   "\r[+] WIF: {}",
   private_key
   );

for more speed....

I have similar levels of performance in Rust and C. But much less bugs in Rust Wink

I love python but blows my memory in no time (cpu). And I have been fight with eclipse all my life.
Doesn't matter how many thread I cant run more than 3 hours bc my memory goes to 100%.

Can you tell me if rust has the same memory issue?

thx