Bitcoin Forum
July 10, 2025, 01:46:31 AM *
News: Latest Bitcoin Core release: 29.0 [Torrent]
 
   Home   Help Search Login Register More  
Pages: « 1 ... 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 [251] 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 ... 549 »
  Print  
Author Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it  (Read 316527 times)
maylabel
Newbie
*
Offline Offline

Activity: 24
Merit: 0


View Profile
May 10, 2024, 08:38:01 AM
 #5001

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
maylabel
Newbie
*
Offline Offline

Activity: 24
Merit: 0


View Profile
May 10, 2024, 08:55:07 AM
 #5002

The Bitcoin puzzle transaction involving multiple addresses generated by a formula with corresponding private key values has intrigued many. The challenge to decipher the formula behind these addresses, with the prize of approximately 32 BTC, remains unsolved, inviting the Bitcoin community's collective efforts and ingenuity to crack it.

Oh, sure! Because nothing screams "fun weekend activity" like trying to crack a cryptographic puzzle for a chance at some digital gold. Who needs Netflix when you can spend hours staring at strings of alphanumeric characters, hoping they form a magical circle that summons the secrets of the universe? It's like a high-stakes Sudoku, except instead of filling in numbers, you're filling in existential dread. But hey, at least you might end up with enough Bitcoin to buy a small tropical island, right? Totally worth it!  Grin

 Cheesy Cheesy Cheesy Cheesy dying by reading that

I had the (dis)pleasure to cross with these puzzles recently, together with k4 of kryptos.
(why Im doing this to myself?lol)

And now I'm surrounding by papers and notes... my broken casio too.

I read so much about the BTC calculation is give me headaches, literally I went to walk an hour to give me a break




nomachine
Full Member
***
Offline Offline

Activity: 700
Merit: 107


View Profile
May 10, 2024, 10:33:07 AM
Last edit: May 10, 2024, 11:11:35 AM by nomachine
 #5003

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

This is the puzzle script from this post :
https://bitcointalk.org/index.php?topic=1306983.msg64052077#msg64052077

https://i.ibb.co/xz2p58j/2024-05-10-12-29.png

It consumes all 12 cores I have. It works rock solid like this for days.
But this is a special machine just for these things. I don't use it for anything else.

BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
maylabel
Newbie
*
Offline Offline

Activity: 24
Merit: 0


View Profile
May 10, 2024, 11:09:29 AM
 #5004

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

This is the puzzle script from this post :
https://bitcointalk.org/index.php?topic=1306983.msg64052077#msg64052077

https://i.ibb.co/xz2p58j/2024-05-10-12-29.png

It consumes all 12 cores I have. It works rock solid like this for days.
But this is a special machine just for these things. I don't use it for anything else.

Wow, you have solid 8x more memory and 3x more cores than I, kudos for you Kiss

I can't just dedicated my cpu for that; I still need to teach tho....
So to compensate I'm using statistics to reduce the range... not perfect but I already cut in half (i believe)

I will try to run your code (even if I never used rust before)

Thx anyways! Wink
k3ntINA
Newbie
*
Offline Offline

Activity: 27
Merit: 0


View Profile
May 10, 2024, 04:22:32 PM
 #5005

It is very surprising that two of my posts were deleted and these two posts were deleted because they were off topic.
there was nothing from the magic circle and nothing obscure, just a simple new arrangement of private keys in hex and decimal format that showed the relationship between the keys.
There are things in this thread that everyone knows are off topic, but they are not deleted. But this arrangement, which is not something special and is a special category, cannot be sent. They delete it
What is the reason?
No problem, I will upload a full video of these on YouTube in an hour.
 It is proven to everyone that consecutive keys from a wallet can be leaked and have bugs.
Now why don't I open a number? I do not have the knowledge of mathematics and programming or the knowledge that is needed to make this connection meaningful.
That's why I couldn't reach the keys, but there are definitely those who, by looking at the numbers, can discover things that the others failed to discover.
Bugs and cracks always appear somewhere and from where no one thought of it, and sometimes they are very simple and very unexpected.
nomachine
Full Member
***
Offline Offline

Activity: 700
Merit: 107


View Profile
May 10, 2024, 05:19:56 PM
 #5006

No problem, I will upload a full video of these on YouTube in an hour.
Bugs and cracks always appear somewhere and from where no one thought of it, and sometimes they are very simple and very unexpected.

Oh, it sounds like we're invited for a thrilling YouTube premiere! Who knew the drama of consecutive keys from a wallet could be so riveting? And here I was, thinking that bugs and cracks only appeared in poorly written software and manuals. Who knows what secrets lie hidden in the labyrinth of ones and zeros? Only time will tell, my friend, only time will tell. But hey, you've got a keen eye for the unexpected - who knows, maybe your next video will uncover the secret of the universe hidden in the digits of pi.  Wink

BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
tifosi87
Newbie
*
Offline Offline

Activity: 4
Merit: 0


View Profile
May 10, 2024, 08:19:01 PM
 #5007

hi all i read the post since one year sorry for my english i found a interesting think but i does takes me further. in every elliptic curve like y^2= x^3+7 there is something interesting like :
if P(1,y1) - k times--> Q(-29/3 ,y2)
   P(2,y3) --k times--> Q(-3,y2)
 so on there is a simple math here where k is always too know independent from whcih curve we work .
 i don't want to give more information this operation is 10 times faster then k*G= and find the x value 
saeedxxx
Newbie
*
Offline Offline

Activity: 28
Merit: 7


View Profile
May 10, 2024, 09:40:10 PM
 #5008

hi all i read the post since one year sorry for my english i found a interesting think but i does takes me further. in every elliptic curve like y^2= x^3+7 there is something interesting like :
if P(1,y1) - k times--> Q(-29/3 ,y2)
   P(2,y3) --k times--> Q(-3,y2)
 so on there is a simple math here where k is always too know independent from whcih curve we work .
 i don't want to give more information this operation is 10 times faster then k*G= and find the x value 

This puzzle is exactly created to test such ideas. You don't need to prove yourself to anyone. just solve puzzle 130# by this algorithm. that's enough
dextronomous
Full Member
***
Offline Offline

Activity: 441
Merit: 105


View Profile
May 10, 2024, 10:22:40 PM
 #5009

ok hi there, k3ntINA, we need so many kind of skills with this, still this could be the only skill needed,
to solve it right, and some, some kind of skills you are showing,
but merely few get the picture, get it, what is your youtube channel, or the link
if you have posted it,
kTimesG
Full Member
***
Offline Offline

Activity: 518
Merit: 130


View Profile
May 11, 2024, 09:20:08 AM
 #5010

hi all i read the post since one year sorry for my english i found a interesting think but i does takes me further. in every elliptic curve like y^2= x^3+7 there is something interesting like :
if P(1,y1) - k times--> Q(-29/3 ,y2)
   P(2,y3) --k times--> Q(-3,y2)
 so on there is a simple math here where k is always too know independent from whcih curve we work .
 i don't want to give more information this operation is 10 times faster then k*G= and find the x value 
Too bad the points need to be on the curve. We already know about the endomorphisms.

I'd say any attempt to break a private key that involves more than a constant amount of scalar multiplications (no matter how well optimized by precomputed tables), has very few chances of success.
Any multiplication means, by definition, more than one addition, more time.

Random key -> multiply and match -> good luck waiting.

First level of magnitude reduction: don't do scalar multiplications.

Second wall to break is then the point addition (and there's one more after that, and finally one more after).  I already said too much, but I believe there's something that can run around 20x in less time (fewer computations) if we know the public key and simplify the question.  Some known details around secp256k1 help a lot.

Off the grid, training pigeons to broadcast signed messages.
maylabel
Newbie
*
Offline Offline

Activity: 24
Merit: 0


View Profile
May 11, 2024, 10:19:27 AM
 #5011

hi all i read the post since one year sorry for my english i found a interesting think but i does takes me further. in every elliptic curve like y^2= x^3+7 there is something interesting like :
if P(1,y1) - k times--> Q(-29/3 ,y2)
   P(2,y3) --k times--> Q(-3,y2)
 so on there is a simple math here where k is always too know independent from whcih curve we work .
 i don't want to give more information this operation is 10 times faster then k*G= and find the x value 
Too bad the points need to be on the curve. We already know about the endomorphisms.

I'd say any attempt to break a private key that involves more than a constant amount of scalar multiplications (no matter how well optimized by precomputed tables), has very few chances of success.
Any multiplication means, by definition, more than one addition, more time.

Random key -> multiply and match -> good luck waiting.

First level of magnitude reduction: don't do scalar multiplications.

Second wall to break is then the point addition (and there's one more after that, and finally one more after).  I already said too much, but I believe there's something that can run around 20x in less time (fewer computations) if we know the public key and simplify the question.  Some known details around secp256k1 help a lot.


Yeah I endorse what is kTimeG is saying.
the problems is way more deep than I even expected, honestly

I'm not specialist in secp256, not even close, but the sheer amount of calculation is above my capacities. Besides my Jupyter and R have an absolutely collapse trying to do the statistics

a simple example, for the puzzle 65 the coordinates are
X: 21769406468394979245979020739332080729679479243955596515614749275274212371227
Y:102907830890434238525231690377346540046672568029169549965500018466490455252476

you will understand very quick floating point problems, if you come from scientific field like me
besides all the shenanigans around binary calculation  Huh

One website I found fantastic is https://learnmeabitcoin.com/
This person need a award because the site is amazing.
Have a lot of calculator and they try to simplify the max possible but honestly is absurdly convoluted.
But I admire their effort, is worth it to take a look

Another stuffs I was reading is this week was

https://pure.tue.nl/ws/portalfiles/portal/128510960/BEP_BSA_298_299_300_301.pdf
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3367674
https://engineering.purdue.edu/kak/compsec/NewLectures/Lecture7.pdf

On this papers you may can guess why K3ntina is trying to push this idea of the circle: its because of the nature of the calculation, sometimes they have a sqrt(2) have on the pi series expansion in the 3order almost the same decimals where some of the addresses can be build on it.
But again, correlation is not causation: k3ntina is suffering of apophenia... very common in conspiracy theorist


again I'm not bitcoin specialist, i'm scientist so I went to my route what is: statistics
Apparently even if is a HD and this are child  wallets, the reality hass one detail: the onwer FORCED to have this structure.
This reminds me a lot of the case of the Profanity (article: https://medium.com/@rebryk/how-to-hack-a-vanity-address-generated-with-profanity-ffad61ecacd2).
Beside my cpu almost meltdown of trying to run that code, the idea from this case is is  very simple, but on bitcoin has one caveat: we dont have the extended public key and is essential on this case.
so my best next guess is to try to see if the pseudo-random numbers interfere in the wallet construction beside the owner own interference.... and Im still learning but looks like has something on that could be use to reduce the range of the search

Btw, on the k3ntina offer, I also offer a zoom meeting to discuss about it  Grin
eggsylacer
Newbie
*
Offline Offline

Activity: 8
Merit: 0


View Profile
May 11, 2024, 06:13:39 PM
 #5012

The concept of a logarithm was invented just a few centuries ago and immediately changed engineering as we know it.

Code:
import math
from mpmath import mp

def calculate_log2(decimal_value):
    log2_value = mp.log(decimal_value, 2)
    return log2_value

def calculate_reverse_log2(log2_value):
    decimal_value = mp.power(2, log2_value)
    return decimal_value

target_numbers = [
    (1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
    (11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
    (17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
    (22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
    (26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
    (30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
    (34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
    (38, 146971536592), (39, 323724968937), (40, 1003651412950),
    (41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
    (44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
    (47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
    (50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
    (53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
    (56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
    (59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
    (62, 3908372542507822062), (63, 8993229949524469768),
    (64, 17799667357578236628), (65, 30568377312064202855)
]

mp.dps = 20  # Set the high decimal precision

for ordinal, decimal_value in target_numbers:
    log2_result = calculate_log2(decimal_value)
    reverse_result = calculate_reverse_log2(log2_result)
    print(f"Puzzle:{ordinal}: Log(2) for {decimal_value} is approximately {log2_result}. Reverse calculation: {reverse_result}")

Look result of this madness:

Puzzle:1: Log(2) for 1 is approximately 0.0. Reverse calculation: 1.0
Puzzle:2: Log(2) for 3 is approximately 1.5849625007211561815. Reverse calculation: 3.0
Puzzle:3: Log(2) for 7 is approximately 2.8073549220576041074. Reverse calculation: 7.0
Puzzle:4: Log(2) for 8 is approximately 3.0. Reverse calculation: 8.0
Puzzle:5: Log(2) for 21 is approximately 4.3923174227787602889. Reverse calculation: 21.0
Puzzle:6: Log(2) for 49 is approximately 5.6147098441152082149. Reverse calculation: 49.0
Puzzle:7: Log(2) for 76 is approximately 6.2479275134435854938. Reverse calculation: 76.0
Puzzle:8: Log(2) for 224 is approximately 7.8073549220576041074. Reverse calculation: 224.0
Puzzle:9: Log(2) for 467 is approximately 8.8672787397096619133. Reverse calculation: 467.0
Puzzle:10: Log(2) for 514 is approximately 9.0056245491938781069. Reverse calculation: 514.0
Puzzle:11: Log(2) for 1155 is approximately 10.173677136303419893. Reverse calculation: 1155.0
Puzzle:12: Log(2) for 2683 is approximately 11.389631339260521112. Reverse calculation: 2683.0
Puzzle:13: Log(2) for 5216 is approximately 12.348728154231077553. Reverse calculation: 5216.0
Puzzle:14: Log(2) for 10544 is approximately 13.364134655008051742. Reverse calculation: 10544.0
Puzzle:15: Log(2) for 26867 is approximately 14.713547616912692731. Reverse calculation: 26867.0
Puzzle:16: Log(2) for 51510 is approximately 15.652564919610652675. Reverse calculation: 51510.0
Puzzle:17: Log(2) for 95823 is approximately 16.548084361224413154. Reverse calculation: 95823.0
Puzzle:18: Log(2) for 198669 is approximately 17.600007248708430135. Reverse calculation: 198669.0
Puzzle:19: Log(2) for 357535 is approximately 18.447724952285439321. Reverse calculation: 357535.0
Puzzle:20: Log(2) for 863317 is approximately 19.719530872026151871. Reverse calculation: 863317.00000000000001
Puzzle:21: Log(2) for 1811764 is approximately 20.788963611792287227. Reverse calculation: 1811764.0
Puzzle:22: Log(2) for 3007503 is approximately 21.520134745822105762. Reverse calculation: 3007503.0
Puzzle:23: Log(2) for 5598802 is approximately 22.416686729787820277. Reverse calculation: 5598802.0
Puzzle:24: Log(2) for 14428676 is approximately 23.782435585948494073. Reverse calculation: 14428676.0
Puzzle:25: Log(2) for 33185509 is approximately 24.984050066697330736. Reverse calculation: 33185509.0
Puzzle:26: Log(2) for 54538862 is approximately 25.700781261712878111. Reverse calculation: 54538862.0
Puzzle:27: Log(2) for 111949941 is approximately 26.738278526958637998. Reverse calculation: 111949941.0
Puzzle:28: Log(2) for 227634408 is approximately 27.762143403294801415. Reverse calculation: 227634408.0
Puzzle:29: Log(2) for 400708894 is approximately 28.577979290797464122. Reverse calculation: 400708894.0
Puzzle:30: Log(2) for 1033162084 is approximately 29.944419458082398243. Reverse calculation: 1033162084.0
Puzzle:31: Log(2) for 2102388551 is approximately 30.969382178280594153. Reverse calculation: 2102388551.0
Puzzle:32: Log(2) for 3093472814 is approximately 31.526580209327912218. Reverse calculation: 3093472814.0
Puzzle:33: Log(2) for 7137437912 is approximately 32.732759144627864676. Reverse calculation: 7137437912.0000000001
Puzzle:34: Log(2) for 14133072157 is approximately 33.718356052472843908. Reverse calculation: 14133072157.0
Puzzle:35: Log(2) for 20112871792 is approximately 34.22740003868583903. Reverse calculation: 20112871792.0
Puzzle:36: Log(2) for 42387769980 is approximately 35.302929017096708804. Reverse calculation: 42387769980.000000001
Puzzle:37: Log(2) for 100251560595 is approximately 36.544833738746849477. Reverse calculation: 100251560595.0
Puzzle:38: Log(2) for 146971536592 is approximately 37.096745824716051977. Reverse calculation: 146971536592.0
Puzzle:39: Log(2) for 323724968937 is approximately 38.235977688802476225. Reverse calculation: 323724968937.0
Puzzle:40: Log(2) for 1003651412950 is approximately 39.868395419757349213. Reverse calculation: 1003651412950.0
Puzzle:41: Log(2) for 1458252205147 is approximately 40.407377394423366271. Reverse calculation: 1458252205147.0
Puzzle:42: Log(2) for 2895374552463 is approximately 41.396887129359569265. Reverse calculation: 2895374552463.0
Puzzle:43: Log(2) for 7409811047825 is approximately 42.752573892536879788. Reverse calculation: 7409811047825.0
Puzzle:44: Log(2) for 15404761757071 is approximately 43.808441604030467369. Reverse calculation: 15404761757071.0
Puzzle:45: Log(2) for 19996463086597 is approximately 44.184810076602017917. Reverse calculation: 19996463086597.0
Puzzle:46: Log(2) for 51408670348612 is approximately 45.547076931749783679. Reverse calculation: 51408670348612.0
Puzzle:47: Log(2) for 119666659114170 is approximately 46.766014580697737785. Reverse calculation: 119666659114170.0
Puzzle:48: Log(2) for 191206974700443 is approximately 47.442128478217754077. Reverse calculation: 191206974700443.0
Puzzle:49: Log(2) for 409118905032525 is approximately 48.539513532885657356. Reverse calculation: 409118905032525.00001
Puzzle:50: Log(2) for 611140496167764 is approximately 49.118497410306637905. Reverse calculation: 611140496167764.0
Puzzle:51: Log(2) for 2058769515153876 is approximately 50.870703748687580964. Reverse calculation: 2058769515153876.0
Puzzle:52: Log(2) for 4216495639600700 is approximately 51.904965885818221825. Reverse calculation: 4216495639600700.0
Puzzle:53: Log(2) for 6763683971478124 is approximately 52.586730675690989872. Reverse calculation: 6763683971478124.0
Puzzle:54: Log(2) for 9974455244496707 is approximately 53.147159473916182081. Reverse calculation: 9974455244496706.9998
Puzzle:55: Log(2) for 30045390491869460 is approximately 54.737993190511333013. Reverse calculation: 30045390491869460.0
Puzzle:56: Log(2) for 44218742292676575 is approximately 55.295507509568065689. Reverse calculation: 44218742292676575.0
Puzzle:57: Log(2) for 138245758910846492 is approximately 56.940012835374135824. Reverse calculation: 138245758910846492.0
Puzzle:58: Log(2) for 199976667976342049 is approximately 57.472609298293031082. Reverse calculation: 199976667976342049.0
Puzzle:59: Log(2) for 525070384258266191 is approximately 58.865288438176815787. Reverse calculation: 525070384258266190.99
Puzzle:60: Log(2) for 1135041350219496382 is approximately 59.977450564669282481. Reverse calculation: 1135041350219496382.0
Puzzle:61: Log(2) for 1425787542618654982 is approximately 60.306464728992728608. Reverse calculation: 1425787542618654982.0
Puzzle:62: Log(2) for 3908372542507822062 is approximately 61.761273698209320329. Reverse calculation: 3908372542507822061.9
Puzzle:63: Log(2) for 8993229949524469768 is approximately 62.963545065677060031. Reverse calculation: 8993229949524469767.8
Puzzle:64: Log(2) for 17799667357578236628 is approximately 63.948484083037149251. Reverse calculation: 17799667357578236628.0
Puzzle:65: Log(2) for 30568377312064202855 is approximately 64.728673773273428832. Reverse calculation: 30568377312064202855.0

So, puzzle 66 private key is from
65.000000000000000000  log(2)
to
66.000000000000000000  log(2)


You can test puzzle 15 (or any) with this formula :

Code:
from mpmath import mp
import random
import secp256k1 as ice
import sys

def calculate_reverse_log2(log2_value):
    decimal_value = mp.power(2, log2_value)
    return decimal_value

mp.dps = 20  # Set the decimal precision to a sufficiently high value
target = "1QCbW9HWnwQWiQqVo5exhAnmfqKRrCRsvW"

while True:
    random_log2_value = mp.mpf(random.uniform(14.0, 15.0))
    reverse_result = calculate_reverse_log2(random_log2_value)
    HEX = "%064x" % int(reverse_result)
    dec = int(HEX, 16)
    caddr = ice.privatekey_to_address(0, True, dec)
    message = "[+] {}".format(dec);messages = [];messages.append(message);output = ''.join(messages) + "\r";sys.stdout.write(output);sys.stdout.flush()
    if target in caddr:
       wifc = ice.btc_pvk_to_wif(HEX)
       print(f"\n\033[32m[+] PUZZLE SOLVED: {wifc} \033[0m")
       break

Result is instant.

I can not see pattern here... Can you see ?? Grin

You can even do regression analysis
https://i.ibb.co/jJYVpd6/Figure-1.png

I'm lost between the size of the numbers and the precision required here . . .

There is no pattern. But it's not random either according to the polynomial analysis. There is an exact math formula for making this puzzle with some script, errors = ZERO.  With high decimal precision (mp.dps = 20 at least)
And the formula is in the creator's mind.

Your polynomial regression plot suggests that the source of this generation is the same.
eggsylacer
Newbie
*
Offline Offline

Activity: 8
Merit: 0


View Profile
May 11, 2024, 06:47:47 PM
 #5013

hi all i read the post since one year sorry for my english i found a interesting think but i does takes me further. in every elliptic curve like y^2= x^3+7 there is something interesting like :
if P(1,y1) - k times--> Q(-29/3 ,y2)
   P(2,y3) --k times--> Q(-3,y2)
 so on there is a simple math here where k is always too know independent from whcih curve we work .
 i don't want to give more information this operation is 10 times faster then k*G= and find the x value 


I think to solve the equation we need to introduce a third Z axis
eggsylacer
Newbie
*
Offline Offline

Activity: 8
Merit: 0


View Profile
May 11, 2024, 08:22:48 PM
 #5014

wish me luck, current speed is 100K keys per sec.

100kk/s is very low. 
You're better off using keyhunt by alberto
You may get +1Mk/s even on a potato CPU



Perhaps his algorithm works exponentially? That is, the time to find the key decreases exponentially.
eggsylacer
Newbie
*
Offline Offline

Activity: 8
Merit: 0


View Profile
May 11, 2024, 09:00:38 PM
 #5015

I formulated the question: is it possible to create a number system in which:

1=1
2=3
3=7
4=8
5=21
6=49
.....

Also I have a question, how did the creator access the addresses above puzl#160 repeatedly? I.e. he was transferring btc from these addresses to smaller addresses. Did he really save every key to the address and "manually" (using an algorithm) spell them out?
pbies
Full Member
***
Offline Offline

Activity: 364
Merit: 197



View Profile
May 11, 2024, 10:51:52 PM
 #5016

If you guys are saying that pubkey is enough to take over any puzzle tx,
then it can be done with any tx that is in mempool.

BTC: bc1qmrexlspd24kevspp42uvjg7sjwm8xcf9w86h5k
maylabel
Newbie
*
Offline Offline

Activity: 24
Merit: 0


View Profile
May 11, 2024, 11:29:33 PM
 #5017

The concept of a logarithm was invented just a few centuries ago and immediately changed engineering as we know it.

Code:
import math
from mpmath import mp

def calculate_log2(decimal_value):
    log2_value = mp.log(decimal_value, 2)
    return log2_value

def calculate_reverse_log2(log2_value):
    decimal_value = mp.power(2, log2_value)
    return decimal_value

target_numbers = [
    (1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
    (11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
    (17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
    (22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
    (26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
    (30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
    (34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
    (38, 146971536592), (39, 323724968937), (40, 1003651412950),
    (41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
    (44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
    (47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
    (50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
    (53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
    (56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
    (59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
    (62, 3908372542507822062), (63, 8993229949524469768),
    (64, 17799667357578236628), (65, 30568377312064202855)
]

mp.dps = 20  # Set the high decimal precision

for ordinal, decimal_value in target_numbers:
    log2_result = calculate_log2(decimal_value)
    reverse_result = calculate_reverse_log2(log2_result)
    print(f"Puzzle:{ordinal}: Log(2) for {decimal_value} is approximately {log2_result}. Reverse calculation: {reverse_result}")

Look result of this madness:

Puzzle:1: Log(2) for 1 is approximately 0.0. Reverse calculation: 1.0
Puzzle:2: Log(2) for 3 is approximately 1.5849625007211561815. Reverse calculation: 3.0
Puzzle:3: Log(2) for 7 is approximately 2.8073549220576041074. Reverse calculation: 7.0
Puzzle:4: Log(2) for 8 is approximately 3.0. Reverse calculation: 8.0
Puzzle:5: Log(2) for 21 is approximately 4.3923174227787602889. Reverse calculation: 21.0
Puzzle:6: Log(2) for 49 is approximately 5.6147098441152082149. Reverse calculation: 49.0
Puzzle:7: Log(2) for 76 is approximately 6.2479275134435854938. Reverse calculation: 76.0
Puzzle:8: Log(2) for 224 is approximately 7.8073549220576041074. Reverse calculation: 224.0
Puzzle:9: Log(2) for 467 is approximately 8.8672787397096619133. Reverse calculation: 467.0
Puzzle:10: Log(2) for 514 is approximately 9.0056245491938781069. Reverse calculation: 514.0
Puzzle:11: Log(2) for 1155 is approximately 10.173677136303419893. Reverse calculation: 1155.0
Puzzle:12: Log(2) for 2683 is approximately 11.389631339260521112. Reverse calculation: 2683.0
Puzzle:13: Log(2) for 5216 is approximately 12.348728154231077553. Reverse calculation: 5216.0
Puzzle:14: Log(2) for 10544 is approximately 13.364134655008051742. Reverse calculation: 10544.0
Puzzle:15: Log(2) for 26867 is approximately 14.713547616912692731. Reverse calculation: 26867.0
Puzzle:16: Log(2) for 51510 is approximately 15.652564919610652675. Reverse calculation: 51510.0
Puzzle:17: Log(2) for 95823 is approximately 16.548084361224413154. Reverse calculation: 95823.0
Puzzle:18: Log(2) for 198669 is approximately 17.600007248708430135. Reverse calculation: 198669.0
Puzzle:19: Log(2) for 357535 is approximately 18.447724952285439321. Reverse calculation: 357535.0
Puzzle:20: Log(2) for 863317 is approximately 19.719530872026151871. Reverse calculation: 863317.00000000000001
Puzzle:21: Log(2) for 1811764 is approximately 20.788963611792287227. Reverse calculation: 1811764.0
Puzzle:22: Log(2) for 3007503 is approximately 21.520134745822105762. Reverse calculation: 3007503.0
Puzzle:23: Log(2) for 5598802 is approximately 22.416686729787820277. Reverse calculation: 5598802.0
Puzzle:24: Log(2) for 14428676 is approximately 23.782435585948494073. Reverse calculation: 14428676.0
Puzzle:25: Log(2) for 33185509 is approximately 24.984050066697330736. Reverse calculation: 33185509.0
Puzzle:26: Log(2) for 54538862 is approximately 25.700781261712878111. Reverse calculation: 54538862.0
Puzzle:27: Log(2) for 111949941 is approximately 26.738278526958637998. Reverse calculation: 111949941.0
Puzzle:28: Log(2) for 227634408 is approximately 27.762143403294801415. Reverse calculation: 227634408.0
Puzzle:29: Log(2) for 400708894 is approximately 28.577979290797464122. Reverse calculation: 400708894.0
Puzzle:30: Log(2) for 1033162084 is approximately 29.944419458082398243. Reverse calculation: 1033162084.0
Puzzle:31: Log(2) for 2102388551 is approximately 30.969382178280594153. Reverse calculation: 2102388551.0
Puzzle:32: Log(2) for 3093472814 is approximately 31.526580209327912218. Reverse calculation: 3093472814.0
Puzzle:33: Log(2) for 7137437912 is approximately 32.732759144627864676. Reverse calculation: 7137437912.0000000001
Puzzle:34: Log(2) for 14133072157 is approximately 33.718356052472843908. Reverse calculation: 14133072157.0
Puzzle:35: Log(2) for 20112871792 is approximately 34.22740003868583903. Reverse calculation: 20112871792.0
Puzzle:36: Log(2) for 42387769980 is approximately 35.302929017096708804. Reverse calculation: 42387769980.000000001
Puzzle:37: Log(2) for 100251560595 is approximately 36.544833738746849477. Reverse calculation: 100251560595.0
Puzzle:38: Log(2) for 146971536592 is approximately 37.096745824716051977. Reverse calculation: 146971536592.0
Puzzle:39: Log(2) for 323724968937 is approximately 38.235977688802476225. Reverse calculation: 323724968937.0
Puzzle:40: Log(2) for 1003651412950 is approximately 39.868395419757349213. Reverse calculation: 1003651412950.0
Puzzle:41: Log(2) for 1458252205147 is approximately 40.407377394423366271. Reverse calculation: 1458252205147.0
Puzzle:42: Log(2) for 2895374552463 is approximately 41.396887129359569265. Reverse calculation: 2895374552463.0
Puzzle:43: Log(2) for 7409811047825 is approximately 42.752573892536879788. Reverse calculation: 7409811047825.0
Puzzle:44: Log(2) for 15404761757071 is approximately 43.808441604030467369. Reverse calculation: 15404761757071.0
Puzzle:45: Log(2) for 19996463086597 is approximately 44.184810076602017917. Reverse calculation: 19996463086597.0
Puzzle:46: Log(2) for 51408670348612 is approximately 45.547076931749783679. Reverse calculation: 51408670348612.0
Puzzle:47: Log(2) for 119666659114170 is approximately 46.766014580697737785. Reverse calculation: 119666659114170.0
Puzzle:48: Log(2) for 191206974700443 is approximately 47.442128478217754077. Reverse calculation: 191206974700443.0
Puzzle:49: Log(2) for 409118905032525 is approximately 48.539513532885657356. Reverse calculation: 409118905032525.00001
Puzzle:50: Log(2) for 611140496167764 is approximately 49.118497410306637905. Reverse calculation: 611140496167764.0
Puzzle:51: Log(2) for 2058769515153876 is approximately 50.870703748687580964. Reverse calculation: 2058769515153876.0
Puzzle:52: Log(2) for 4216495639600700 is approximately 51.904965885818221825. Reverse calculation: 4216495639600700.0
Puzzle:53: Log(2) for 6763683971478124 is approximately 52.586730675690989872. Reverse calculation: 6763683971478124.0
Puzzle:54: Log(2) for 9974455244496707 is approximately 53.147159473916182081. Reverse calculation: 9974455244496706.9998
Puzzle:55: Log(2) for 30045390491869460 is approximately 54.737993190511333013. Reverse calculation: 30045390491869460.0
Puzzle:56: Log(2) for 44218742292676575 is approximately 55.295507509568065689. Reverse calculation: 44218742292676575.0
Puzzle:57: Log(2) for 138245758910846492 is approximately 56.940012835374135824. Reverse calculation: 138245758910846492.0
Puzzle:58: Log(2) for 199976667976342049 is approximately 57.472609298293031082. Reverse calculation: 199976667976342049.0
Puzzle:59: Log(2) for 525070384258266191 is approximately 58.865288438176815787. Reverse calculation: 525070384258266190.99
Puzzle:60: Log(2) for 1135041350219496382 is approximately 59.977450564669282481. Reverse calculation: 1135041350219496382.0
Puzzle:61: Log(2) for 1425787542618654982 is approximately 60.306464728992728608. Reverse calculation: 1425787542618654982.0
Puzzle:62: Log(2) for 3908372542507822062 is approximately 61.761273698209320329. Reverse calculation: 3908372542507822061.9
Puzzle:63: Log(2) for 8993229949524469768 is approximately 62.963545065677060031. Reverse calculation: 8993229949524469767.8
Puzzle:64: Log(2) for 17799667357578236628 is approximately 63.948484083037149251. Reverse calculation: 17799667357578236628.0
Puzzle:65: Log(2) for 30568377312064202855 is approximately 64.728673773273428832. Reverse calculation: 30568377312064202855.0

So, puzzle 66 private key is from
65.000000000000000000  log(2)
to
66.000000000000000000  log(2)


You can test puzzle 15 (or any) with this formula :

Code:
from mpmath import mp
import random
import secp256k1 as ice
import sys

def calculate_reverse_log2(log2_value):
    decimal_value = mp.power(2, log2_value)
    return decimal_value

mp.dps = 20  # Set the decimal precision to a sufficiently high value
target = "1QCbW9HWnwQWiQqVo5exhAnmfqKRrCRsvW"

while True:
    random_log2_value = mp.mpf(random.uniform(14.0, 15.0))
    reverse_result = calculate_reverse_log2(random_log2_value)
    HEX = "%064x" % int(reverse_result)
    dec = int(HEX, 16)
    caddr = ice.privatekey_to_address(0, True, dec)
    message = "[+] {}".format(dec);messages = [];messages.append(message);output = ''.join(messages) + "\r";sys.stdout.write(output);sys.stdout.flush()
    if target in caddr:
       wifc = ice.btc_pvk_to_wif(HEX)
       print(f"\n\033[32m[+] PUZZLE SOLVED: {wifc} \033[0m")
       break

Result is instant.

I can not see pattern here... Can you see ?? Grin

You can even do regression analysis
https://i.ibb.co/jJYVpd6/Figure-1.png

I'm lost between the size of the numbers and the precision required here . . .

There is no pattern. But it's not random either according to the polynomial analysis. There is an exact math formula for making this puzzle with some script, errors = ZERO.  With high decimal precision (mp.dps = 20 at least)
And the formula is in the creator's mind.

Your polynomial regression plot suggests that the source of this generation is the same.

OMG, sorry if their any scientist here, but this IS THE NATURE OF THE PUZZLE !!! Roll Eyes

It IS BUILDING on powers of 2 ranges of hex.
puzzle 65 - 2^64 to 2^65
puzzle 64 - 2^63 to 2^64
puzzle 63 - 2^62 to 2^63 and so on...

so its OBVIOUS will appear a power of 2 graph.
Now I invited you to the the standard deviation and realize the size of problem...

This is NOT what I pointed out...
The reality is: when you do a HD wallet with the child ( there are 213 childs from the original) is very hard to create on deterministic range of hex.
The fact you need the parent extended public key, is because you need the chain code (32 bytes) to do the math.
Its not a simple factor....

That's why remembered me a lot how profanity works
But is crucial to understand first how HD wallets works btw
nomachine
Full Member
***
Offline Offline

Activity: 700
Merit: 107


View Profile
May 12, 2024, 07:52:26 AM
Last edit: May 12, 2024, 08:03:40 AM by nomachine
 #5018

If you guys are saying that pubkey is enough to take over any puzzle tx,
then it can be done with any tx that is in mempool.

It is possible, but it requires knowledge of the private key range with a minimum precision width of Puzzle 30 scale, so that you could brute-force the private key on a potato PC. The key thing here is that we know the exact ranges of the keys for puzzles. And on too big like Puzzle 130, that factor doesn't help us either. Due to lack of hardware.

BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
eggsylacer
Newbie
*
Offline Offline

Activity: 8
Merit: 0


View Profile
May 12, 2024, 07:58:27 AM
 #5019

The concept of a logarithm was invented just a few centuries ago and immediately changed engineering as we know it.

Code:
import math
from mpmath import mp

def calculate_log2(decimal_value):
    log2_value = mp.log(decimal_value, 2)
    return log2_value

def calculate_reverse_log2(log2_value):
    decimal_value = mp.power(2, log2_value)
    return decimal_value

target_numbers = [
    (1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
    (11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
    (17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
    (22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
    (26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
    (30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
    (34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
    (38, 146971536592), (39, 323724968937), (40, 1003651412950),
    (41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
    (44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
    (47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
    (50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
    (53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
    (56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
    (59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
    (62, 3908372542507822062), (63, 8993229949524469768),
    (64, 17799667357578236628), (65, 30568377312064202855)
]

mp.dps = 20  # Set the high decimal precision

for ordinal, decimal_value in target_numbers:
    log2_result = calculate_log2(decimal_value)
    reverse_result = calculate_reverse_log2(log2_result)
    print(f"Puzzle:{ordinal}: Log(2) for {decimal_value} is approximately {log2_result}. Reverse calculation: {reverse_result}")

Look result of this madness:

Puzzle:1: Log(2) for 1 is approximately 0.0. Reverse calculation: 1.0
Puzzle:2: Log(2) for 3 is approximately 1.5849625007211561815. Reverse calculation: 3.0
Puzzle:3: Log(2) for 7 is approximately 2.8073549220576041074. Reverse calculation: 7.0
Puzzle:4: Log(2) for 8 is approximately 3.0. Reverse calculation: 8.0
Puzzle:5: Log(2) for 21 is approximately 4.3923174227787602889. Reverse calculation: 21.0
Puzzle:6: Log(2) for 49 is approximately 5.6147098441152082149. Reverse calculation: 49.0
Puzzle:7: Log(2) for 76 is approximately 6.2479275134435854938. Reverse calculation: 76.0
Puzzle:8: Log(2) for 224 is approximately 7.8073549220576041074. Reverse calculation: 224.0
Puzzle:9: Log(2) for 467 is approximately 8.8672787397096619133. Reverse calculation: 467.0
Puzzle:10: Log(2) for 514 is approximately 9.0056245491938781069. Reverse calculation: 514.0
Puzzle:11: Log(2) for 1155 is approximately 10.173677136303419893. Reverse calculation: 1155.0
Puzzle:12: Log(2) for 2683 is approximately 11.389631339260521112. Reverse calculation: 2683.0
Puzzle:13: Log(2) for 5216 is approximately 12.348728154231077553. Reverse calculation: 5216.0
Puzzle:14: Log(2) for 10544 is approximately 13.364134655008051742. Reverse calculation: 10544.0
Puzzle:15: Log(2) for 26867 is approximately 14.713547616912692731. Reverse calculation: 26867.0
Puzzle:16: Log(2) for 51510 is approximately 15.652564919610652675. Reverse calculation: 51510.0
Puzzle:17: Log(2) for 95823 is approximately 16.548084361224413154. Reverse calculation: 95823.0
Puzzle:18: Log(2) for 198669 is approximately 17.600007248708430135. Reverse calculation: 198669.0
Puzzle:19: Log(2) for 357535 is approximately 18.447724952285439321. Reverse calculation: 357535.0
Puzzle:20: Log(2) for 863317 is approximately 19.719530872026151871. Reverse calculation: 863317.00000000000001
Puzzle:21: Log(2) for 1811764 is approximately 20.788963611792287227. Reverse calculation: 1811764.0
Puzzle:22: Log(2) for 3007503 is approximately 21.520134745822105762. Reverse calculation: 3007503.0
Puzzle:23: Log(2) for 5598802 is approximately 22.416686729787820277. Reverse calculation: 5598802.0
Puzzle:24: Log(2) for 14428676 is approximately 23.782435585948494073. Reverse calculation: 14428676.0
Puzzle:25: Log(2) for 33185509 is approximately 24.984050066697330736. Reverse calculation: 33185509.0
Puzzle:26: Log(2) for 54538862 is approximately 25.700781261712878111. Reverse calculation: 54538862.0
Puzzle:27: Log(2) for 111949941 is approximately 26.738278526958637998. Reverse calculation: 111949941.0
Puzzle:28: Log(2) for 227634408 is approximately 27.762143403294801415. Reverse calculation: 227634408.0
Puzzle:29: Log(2) for 400708894 is approximately 28.577979290797464122. Reverse calculation: 400708894.0
Puzzle:30: Log(2) for 1033162084 is approximately 29.944419458082398243. Reverse calculation: 1033162084.0
Puzzle:31: Log(2) for 2102388551 is approximately 30.969382178280594153. Reverse calculation: 2102388551.0
Puzzle:32: Log(2) for 3093472814 is approximately 31.526580209327912218. Reverse calculation: 3093472814.0
Puzzle:33: Log(2) for 7137437912 is approximately 32.732759144627864676. Reverse calculation: 7137437912.0000000001
Puzzle:34: Log(2) for 14133072157 is approximately 33.718356052472843908. Reverse calculation: 14133072157.0
Puzzle:35: Log(2) for 20112871792 is approximately 34.22740003868583903. Reverse calculation: 20112871792.0
Puzzle:36: Log(2) for 42387769980 is approximately 35.302929017096708804. Reverse calculation: 42387769980.000000001
Puzzle:37: Log(2) for 100251560595 is approximately 36.544833738746849477. Reverse calculation: 100251560595.0
Puzzle:38: Log(2) for 146971536592 is approximately 37.096745824716051977. Reverse calculation: 146971536592.0
Puzzle:39: Log(2) for 323724968937 is approximately 38.235977688802476225. Reverse calculation: 323724968937.0
Puzzle:40: Log(2) for 1003651412950 is approximately 39.868395419757349213. Reverse calculation: 1003651412950.0
Puzzle:41: Log(2) for 1458252205147 is approximately 40.407377394423366271. Reverse calculation: 1458252205147.0
Puzzle:42: Log(2) for 2895374552463 is approximately 41.396887129359569265. Reverse calculation: 2895374552463.0
Puzzle:43: Log(2) for 7409811047825 is approximately 42.752573892536879788. Reverse calculation: 7409811047825.0
Puzzle:44: Log(2) for 15404761757071 is approximately 43.808441604030467369. Reverse calculation: 15404761757071.0
Puzzle:45: Log(2) for 19996463086597 is approximately 44.184810076602017917. Reverse calculation: 19996463086597.0
Puzzle:46: Log(2) for 51408670348612 is approximately 45.547076931749783679. Reverse calculation: 51408670348612.0
Puzzle:47: Log(2) for 119666659114170 is approximately 46.766014580697737785. Reverse calculation: 119666659114170.0
Puzzle:48: Log(2) for 191206974700443 is approximately 47.442128478217754077. Reverse calculation: 191206974700443.0
Puzzle:49: Log(2) for 409118905032525 is approximately 48.539513532885657356. Reverse calculation: 409118905032525.00001
Puzzle:50: Log(2) for 611140496167764 is approximately 49.118497410306637905. Reverse calculation: 611140496167764.0
Puzzle:51: Log(2) for 2058769515153876 is approximately 50.870703748687580964. Reverse calculation: 2058769515153876.0
Puzzle:52: Log(2) for 4216495639600700 is approximately 51.904965885818221825. Reverse calculation: 4216495639600700.0
Puzzle:53: Log(2) for 6763683971478124 is approximately 52.586730675690989872. Reverse calculation: 6763683971478124.0
Puzzle:54: Log(2) for 9974455244496707 is approximately 53.147159473916182081. Reverse calculation: 9974455244496706.9998
Puzzle:55: Log(2) for 30045390491869460 is approximately 54.737993190511333013. Reverse calculation: 30045390491869460.0
Puzzle:56: Log(2) for 44218742292676575 is approximately 55.295507509568065689. Reverse calculation: 44218742292676575.0
Puzzle:57: Log(2) for 138245758910846492 is approximately 56.940012835374135824. Reverse calculation: 138245758910846492.0
Puzzle:58: Log(2) for 199976667976342049 is approximately 57.472609298293031082. Reverse calculation: 199976667976342049.0
Puzzle:59: Log(2) for 525070384258266191 is approximately 58.865288438176815787. Reverse calculation: 525070384258266190.99
Puzzle:60: Log(2) for 1135041350219496382 is approximately 59.977450564669282481. Reverse calculation: 1135041350219496382.0
Puzzle:61: Log(2) for 1425787542618654982 is approximately 60.306464728992728608. Reverse calculation: 1425787542618654982.0
Puzzle:62: Log(2) for 3908372542507822062 is approximately 61.761273698209320329. Reverse calculation: 3908372542507822061.9
Puzzle:63: Log(2) for 8993229949524469768 is approximately 62.963545065677060031. Reverse calculation: 8993229949524469767.8
Puzzle:64: Log(2) for 17799667357578236628 is approximately 63.948484083037149251. Reverse calculation: 17799667357578236628.0
Puzzle:65: Log(2) for 30568377312064202855 is approximately 64.728673773273428832. Reverse calculation: 30568377312064202855.0

So, puzzle 66 private key is from
65.000000000000000000  log(2)
to
66.000000000000000000  log(2)


You can test puzzle 15 (or any) with this formula :

Code:
from mpmath import mp
import random
import secp256k1 as ice
import sys

def calculate_reverse_log2(log2_value):
    decimal_value = mp.power(2, log2_value)
    return decimal_value

mp.dps = 20  # Set the decimal precision to a sufficiently high value
target = "1QCbW9HWnwQWiQqVo5exhAnmfqKRrCRsvW"

while True:
    random_log2_value = mp.mpf(random.uniform(14.0, 15.0))
    reverse_result = calculate_reverse_log2(random_log2_value)
    HEX = "%064x" % int(reverse_result)
    dec = int(HEX, 16)
    caddr = ice.privatekey_to_address(0, True, dec)
    message = "[+] {}".format(dec);messages = [];messages.append(message);output = ''.join(messages) + "\r";sys.stdout.write(output);sys.stdout.flush()
    if target in caddr:
       wifc = ice.btc_pvk_to_wif(HEX)
       print(f"\n\033[32m[+] PUZZLE SOLVED: {wifc} \033[0m")
       break

Result is instant.

I can not see pattern here... Can you see ?? Grin

You can even do regression analysis
https://i.ibb.co/jJYVpd6/Figure-1.png

I'm lost between the size of the numbers and the precision required here . . .

There is no pattern. But it's not random either according to the polynomial analysis. There is an exact math formula for making this puzzle with some script, errors = ZERO.  With high decimal precision (mp.dps = 20 at least)
And the formula is in the creator's mind.

Your polynomial regression plot suggests that the source of this generation is the same.

OMG, sorry if their any scientist here, but this IS THE NATURE OF THE PUZZLE !!! Roll Eyes

It IS BUILDING on powers of 2 ranges of hex.
puzzle 65 - 2^64 to 2^65
puzzle 64 - 2^63 to 2^64
puzzle 63 - 2^62 to 2^63 and so on...

so its OBVIOUS will appear a power of 2 graph.
Now I invited you to the the standard deviation and realize the size of problem...

This is NOT what I pointed out...
The reality is: when you do a HD wallet with the child ( there are 213 childs from the original) is very hard to create on deterministic range of hex.
The fact you need the parent extended public key, is because you need the chain code (32 bytes) to do the math.
Its not a simple factor....

That's why remembered me a lot how profanity works
But is crucial to understand first how HD wallets works btw

This puzzle is very strange. If it's for measuring the world's brute forcing capacity, 161-256 are just a waste (RIPEMD160 entropy is filled by 160, and by all of P2PKH Bitcoin). The puzzle creator could improve the puzzle's utility without bringing in any extra funds from outside - just spend 161-256 across to the unsolved portion 51-160, and roughly treble the puzzle's content density.

If on the other hand there's a pattern to find... well... that's awfully open-ended... can we have a hint or two? Cheesy

I am the creator.

You are quite right, 161-256 are silly.  I honestly just did not think of this.  What is especially embarrassing, is this did not occur to me once, in two years.  By way of excuse, I was not really thinking much about the puzzle at all.

I will make up for two years of stupidity.  I will spend from 161-256 to the unsolved parts, as you suggest.  In addition, I intend to add further funds.  My aim is to boost the density by a factor of 10, from 0.001*length(key) to 0.01*length(key).  Probably in the next few weeks.  At any rate, when I next have an extended period of quiet and calm, to construct the new transaction carefully.

A few words about the puzzle.  There is no pattern.  It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty).  It is simply a crude measuring instrument, of the cracking strength of the community.

Finally, I wish to express appreciation of the efforts of all developers of new cracking tools and technology.  The "large bitcoin collider" is especially innovative and interesting!


It's not a puzzle in the sense of the word puzzle. It is a
Quote
"It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty)."
Since the function on the graph of Polynomial Regression of Log(2) behaves as linear, we can assume that the sequence generated by this function has one source.

P.S. If you don't know what I'm talking about, there's no point in opening a dispute.
nomachine
Full Member
***
Offline Offline

Activity: 700
Merit: 107


View Profile
May 12, 2024, 08:51:24 AM
Last edit: May 12, 2024, 09:15:36 AM by nomachine
 #5020

So.....here is a new toy.

puzzle 66 private key is from
65.00000000000000 to
65.99999999999999  Log(2)

Code:
import math
import sys
import secp256k1 as ice


# Function to convert Log(2) to decimal number
def log2_to_decimal(log2_value):
    return 2 ** log2_value

# Range of Log(2) values
start_log2 = 65.00000000000000
end_log2 = 65.99999999999999

# Number of decimal places for Log(2)
decimal_places = 15

target_caddr = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"

# Iterate through the range and calculate decimal numbers
for i in range(int(start_log2 * 10**decimal_places), int((end_log2 + 10**-decimal_places) * 10**decimal_places)):
    log2_value = i / 10**decimal_places
    decimal_number = log2_to_decimal(log2_value)
    HEX = "%064x" % int(decimal_number)
    dec = int(HEX, 16)
    caddr = ice.privatekey_to_address(0, True, dec)
    message = "\r[+] {}".format(dec)
    messages = []
    messages.append(message)
    output = ''.join(messages) + "\r"
    sys.stdout.write(output)
    sys.stdout.flush()
    if caddr == target_caddr:
       wifc = ice.btc_pvk_to_wif(HEX)
       print(wifc)
       break

This  experimental log(2) method skips decimal numbers on the fly as desired in "decimal_places" . . .
Maybe someone can guess on luck what the "decimal_places" number is (from 1 to 17) .  Grin

BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
Pages: « 1 ... 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 [251] 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 ... 549 »
  Print  
 
Jump to:  

Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!