Bitcoin puzzle transaction ~32 BTC prize to who solves it

[bibilgin]

What is the value of n? idk? can you explain?

Let me explain it simply.

The n value has no meaning.

Because it consists of multiples of the Decimal equivalent of the wallet that is written.

Example 67. For the wallet:

Hex: 730FC235C1942C1AE
Decimal: 132656943602386256302

You can write;

132656943602386256302 for the n value.
132656943602386256302 x 2 = 265313887204772512604
132656943602386256302 x 3 = 397970830807158768906

So KTimesG has proven that it is useless. If you already know the Hex Code, then you know the password of the wallet.

[mjojo]

Maybe faster.

Can we end this useless shenanigan now?

useless_shenanigan.py

Code:

import hashlib
import time

import sympy
import ecdsa
import base58


n = 650101855847373604127500588369088602937332557710
addr = '1BP7ByGjkekGpUPweRGjBVWWa6hagnnrnm'


def match(pk):
    pub_key = ecdsa.SigningKey.from_string(
        pk.to_bytes(32), curve=ecdsa.SECP256k1
    ).verifying_key.to_string('compressed')

    return h160 == hashlib.new(
        'ripemd160', hashlib.sha256(pub_key).digest()).digest()


# Recursive generator with fast return path
def gen_subproducts(factors, seen: set, idx=0, prod=1):
    if idx == len(factors):
        if prod > 1 and prod not in seen:
            seen.add(prod)

            if match(prod):
                print(f'Key found: {hex(prod)}')
                return True
        return

    factor, exp = factors[idx]

    for i in range(exp + 1):
        if gen_subproducts(factors, seen, idx + 1, prod * (factor ** i)):
            return True


st = time.monotonic_ns()

h160 = base58.b58decode_check(addr)[1:]
print(f'Target H160: {h160.hex():>040s}')

factors = list(sympy.factorint(n).items())
seen = set()

if not gen_subproducts(factors, seen):
    print('Key not found :(')

print(f'Total unique keys checked: {len(seen)}')
print(f'Total time: {(time.monotonic_ns() - st)/1_000_000:.3f} ms')

Target H160: 71df934f84e9e59bff99e21cc616430ed6727307
Key found: 0xe51e464444fc4495991b7852b855
Total unique keys checked: 337
Total time: 68.625 ms

What is the value of n? idk? can you explain?

Hash address = 650101855847377708352220037630494457385666638599
Private key     = 4647070390595078127527541530081365
Quotient         = Hash address / Private key
                      = 139,894,987,853,654.88318539950579424988

n                  = Quotient x Private key
                    = 139,894,987,853,654 x 4647070390595078127527541530081365
                    = 650101855847373604127500588369088602937332557710

[hoanghuy2912]

What is the value of n? idk? can you explain?

Let me explain it simply.

The n value has no meaning.

Because it consists of multiples of the Decimal equivalent of the wallet that is written.

Example 67. For the wallet:

Hex: 730FC235C1942C1AE
Decimal: 132656943602386256302

You can write;

132656943602386256302 for the n value.
132656943602386256302 x 2 = 265313887204772512604
132656943602386256302 x 3 = 397970830807158768906

So KTimesG has proven that it is useless. If you already know the Hex Code, then you know the password of the wallet.

I still don't understand what the purpose of this is, it seems a bit pointless

[kTimesG]

I still don't understand what the purpose of this is, it seems a bit pointless

The purpose was that a few people asked for the script for this pointless method that @whistle307194 is bragging about for the last few pages, like it's some sort of wonder or something. There is nothing useful about it that would help with anything. In fact, there was not even the need for any script, to figure it out.

[cctv5go]

Cheers 🍻 Puzzle 68.Good luck!

[dastic]

I still don't understand what the purpose of this is, it seems a bit pointless

The purpose was that a few people asked for the script for this pointless method that @whistle307194 is bragging about for the last few pages, like it's some sort of wonder or something. There is nothing useful about it that would help with anything. In fact, there was not even the need for any script, to figure it out.

I'm having a second thought that there might be something to it actually. The thing is that we know how many characters decimal privkey will have and how many the pubkey hash decimal has, and quotient as well - this eliminates stupid calculations and reduces the searchspace. But I am not sure, I already have a headache  


Example puzzle 36:

privkey = x (11 characters)

quotient (y) = pubkey hash / Private key - so it will have 38 digits

n = quotient (y) * private key

and we know that n will have starting characters exactly same as pubkey hash -
                        6662096808 (and rest will be same amount of characters as pubkey hash, just different)

Edit: we still need to check agaist pubkey hash all solutions but seems its less work

[kTimesG]

I'm having a second thought that there might be something to it actually. The thing is that we know how many characters decimal privkey will have and how many the pubkey hash decimal has, and quotient as well - this eliminates stupid calculations and reduces the searchspace. But I am not sure, I already have a headache  


Example puzzle 36:

privkey = x (11 characters)

quotient (y) = pubkey hash / Private key - so it will have 38 digits

n = quotient (y) * private key

and we know that n will have starting characters exactly same as pubkey hash -
                        6662096808 (and rest will be same amount of characters as pubkey hash, just different)

Edit: we still need to check agaist pubkey hash all solutions but seems its less work

What are you talking about? H160 has 160 bits, Puzzle 36 has 35-bit privKey. Quotient is 125 bits, and you don't know it (unless you know privKey). So the problem size is now escalated 2**90 times.

Same bad news for Puzzle 68. This is not a shortcut, it's not even good as a magic trick.

LE: well, ok, I forgot that bit N is set to 1. So puzzle N has a N-bit privKey. But cracking the quotient instead of simply iterating through the private keys is much slower, since you have to do a point-scalar multiplication at every step, instead of going over public keys one after the other.

[dastic]

I'm having a second thought that there might be something to it actually. The thing is that we know how many characters decimal privkey will have and how many the pubkey hash decimal has, and quotient as well - this eliminates stupid calculations and reduces the searchspace. But I am not sure, I already have a headache  


Example puzzle 36:

privkey = x (11 characters)

quotient (y) = pubkey hash / Private key - so it will have 38 digits

n = quotient (y) * private key

and we know that n will have starting characters exactly same as pubkey hash -
                        6662096808 (and rest will be same amount of characters as pubkey hash, just different)

Edit: we still need to check agaist pubkey hash all solutions but seems its less work

What are you talking about? H160 has 160 bits, Puzzle 36 has 35-bit privKey. Quotient is 125 bits, and you don't know it (unless you know privKey). So the problem size is now escalated 2**90 times.

Same bad news for Puzzle 68. This is not a shortcut, it's not even good as a magic trick.

LE: well, ok, I forgot that bit N is set to 1. So puzzle N has a N-bit privKey. But cracking the quotient instead of simply iterating through the private keys is much slower, since you have to do a point-scalar multiplication at every step, instead of going over public keys one after the other.

But you know how many digit it has, and it does not require cryptographic operations which are costly for the hardware

[kTimesG]

But you know how many digit it has, and it does not require cryptographic operations which are costly for the hardware

Fantastic. I'm going fishing, since now everything sorted out with secp256k1 and hash160. Maybe I'll run into nomachine to exchange some code. Or fish.

[legorange]

Code:

import pandas as pd
import matplotlib.pyplot as plt
from collections import Counter

# Lista de valores en porcentaje
percentages = [
    100, 100, 100, 0, 33.33, 54.84, 19.05, 75.59, 82.75, 0.39, 12.81, 31.02, 27.35, 
    28.71, 63.99, 57.2, 46.21, 51.57, 36.39, 64.66, 72.78, 43.41, 33.49, 72, 97.8, 
    62.54, 66.82, 69.6, 49.28, 92.44, 95.8, 44.05, 66.18, 64.53, 17.07, 23.36, 45.89, 
    6.94, 17.77, 82.56, 32.63, 31.67, 68.48, 75.13, 13.67, 46.11, 70.06, 35.86, 45.35, 
    8.56, 82.86, 87.25, 50.18, 10.74, 66.79, 22.73, 91.85, 38.76, 82.17, 96.9, 23.67, 
    69.5, 95.01, 92.98, 65.71, 25.62, 64.4, 19.32, 82.89, 9.03, 40.23, 28.87, 36.98, 
    43.39, 67.98, 51.49, 38.33, 77.03, 62.2
]

# Contar frecuencia de valores
counter = Counter(percentages)
most_common_value, most_common_count = counter.most_common(1)[0]

# Crear un histograma de las distribuciones
plt.figure(figsize=(10, 5))
plt.hist(percentages, bins=20, edgecolor="black", alpha=0.7)
plt.xlabel("Porcentaje de rango de solución")
plt.ylabel("Frecuencia")
plt.title("Distribución de los valores de porcentaje en los puzzles resueltos")
plt.grid(axis='y', linestyle='--', alpha=0.7)

# Mostrar el histograma
plt.show()

# Determinar el intervalo donde más soluciones caen
df = pd.DataFrame(percentages, columns=["Porcentaje"])
df["Intervalo"] = pd.cut(df["Porcentaje"], bins=[0, 20, 40, 60, 80, 100], labels=["0-20%", "20-40%", "40-60%", "60-80%", "80-100%"])
interval_counts = df["Intervalo"].value_counts()

# Mostrar los resultados
most_common_value, most_common_count, interval_counts

Resultado
(100,
 3,
 60-80%     20
 20-40%     17
 80-100%    16
 40-60%     14
 0-20%      11
 Name: Intervalo, dtype: int64)

https://drive.google.com/file/d/1mh24LpF-iJl6odVHM8jFmeHbHP7yf9RI/view?usp=sharing

El intervalo donde más soluciones caen es: 60-80%, con 20 soluciones dentro de ese rango.

Code:

# Definir los límites en decimal del rango del puzle 67
start_decimal = int("40000000000000000", 16)  # Inicio del rango en decimal
end_decimal = int("7ffffffffffffffff", 16)   # Fin del rango en decimal

# Calcular el rango total
range_size = end_decimal - start_decimal

# Calcular los límites del 60-80% del rango
start_60 = start_decimal + int(range_size * 0.60)
end_80 = start_decimal + int(range_size * 0.80)

# Convertir los valores de vuelta a hexadecimal
start_60_hex = hex(start_60)
end_80_hex = hex(end_80)

(start_60_hex, end_80_hex)

Resultado;

('0x66666666666666000', '0x73333333333334000')

Hexadecimal Range to Search in Puzzle 67 (60-80%)
To find the solution to puzzle 67 within the 60-80% of its search space, you should search between:

Start (60% of the range): 0x66666666666666000
End (80% of the range): 0x73333333333334000

LQQD 730fc235c1942c1ae (79.78%)

This is the hexadecimal interval where the probability of finding the solution is highest based on the data from the solved puzzles.

Since many of the remaining puzzles are expected to fall within the 60-80% range by pure statistics, you could focus only on this 20% and disregard the other 80% of the search space.


Subsequently, as there are 20 puzzles solved (already 21), in the interval 60% - 80%, we can divide that range in turn into 5 key subranges based on the previous solutions that appeared in that range.

Code:

import numpy as np

# Filtrar los valores que están en el rango 60-80%
filtered_values = [p for p in percentages if 60 <= p <= 80]

# Dividir el rango 60-80 en 5 sub-intervalos basados en los valores más comunes
num_intervals = 5
percentile_bins = np.linspace(60, 80, num_intervals + 1)  # Crear 5 sub-rangos dentro del 60-80%

# Contar cuántos valores caen en cada sub-intervalo
interval_counts = {}
for i in range(num_intervals):
    lower, upper = percentile_bins[i], percentile_bins[i + 1]
    count = sum(1 for p in filtered_values if lower <= p < upper)
    interval_counts[(lower, upper)] = count

# Ordenar por los intervalos con más valores y seleccionar los 5 más relevantes
best_intervals = sorted(interval_counts.items(), key=lambda x: x[1], reverse=True)[:5]

# Convertir estos intervalos de porcentaje a los rangos en hexadecimal dentro del puzzle 67
best_hex_ranges = []
for (lower, upper), _ in best_intervals:
    start_hex = hex(start_decimal + int(range_size * (lower / 100)))
    end_hex = hex(start_decimal + int(range_size * (upper / 100)))
    best_hex_ranges.append((start_hex, end_hex))

# Show the top 5 sub-ranges to search in puzzle 67
best_hex_ranges

Solution:
Optimal Ranges to Search for Puzzle 67 (Based on Success Data from Other Puzzles)
To increase your chances of finding the solution, here are the top 5 ranges within the 60-80% where you should focus your search:

from 0x68f5c28f5c28f6000 to 0x6b851eb851eb86000
from 0x6b851eb851eb86000 to 0x6e147ae147ae14000
from 0x6e147ae147ae14000 to 0x70a3d70a3d70a4000
from 0x66666666666666000 to 0x68f5c28f5c28f6000
from 0x70a3d70a3d70a4000 to 0x73333333333334000 --in this range -- LQQD 730fc235c1942c1ae (79.78%)

[mjojo]

Did you stupid or morron?? Posting useless shit and spend page to much??

[CanalGanheAgora]

Did you stupid or morron?? Posting useless shit and spend page to much??

Okay bro. Keep calm. I deleted one. I'll leave the others just as examples.

[JackMazzoni]

Did you stupid or morron?? Posting useless shit and spend page to much??

Okay bro. Keep calm. I deleted one. I'll leave the others just as examples.

What this data means? Can you explain further or label it?

[CanalGanheAgora]

Did you stupid or morron?? Posting useless shit and spend page to much??

Okay bro. Keep calm. I deleted one. I'll leave the others just as examples.

What this data means? Can you explain further or label it?

Between these intervals from 1.01 to 1.99 multiplied by the starting value we will have 99 intervals in which the key can be found by choosing one of the specific intervals. For example: 7304ab606b7aa4000:73a92a30553264000. It would solve puzzle 67 faster for those with greater search power or for those who want to try it randomly.

[WanderingPhilospher]

Did you stupid or morron?? Posting useless shit and spend page to much??

Okay bro. Keep calm. I deleted one. I'll leave the others just as examples.

What this data means? Can you explain further or label it?

Between these intervals from 1.01 to 1.99 multiplied by the starting value we will have 99 intervals in which the key can be found by choosing one of the specific intervals. For example: 7304ab606b7aa4000:73a92a30553264000. It would solve puzzle 67 faster for those with greater search power or for those who want to try it randomly.

So tell me if I am wrong...

If one took the start range:
0x40000000000000000

And subtracted it from the end range:
0x7FFFFFFFFFFFFFFFF

Resulting in:
0x3FFFFFFFFFFFFFFFF

and divided that by let's say, oh I dunno, 99, we would have a total of 99 ranges (intervals) to search in. And the key would be found by choosing one of those specific intervals, right?
We accomplished the same thing, but my explanation only ate up about 13 lines, and your explanation took up almost 3 terabytes of forum space. Crazy huh?

[frozenen]

useless_shenanigans part 2:

import hashlib
import time
import sympy
import ecdsa
import base58
import random

# Given constants
var_hash160dec = 1282931445580409769159733555522242769745473092945
min_range = 242965459430942930354
max_range = 276313659744993920795
addr = '1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ'

def match(pk):
    pub_key = ecdsa.SigningKey.from_string(
        pk.to_bytes(32, 'big'), curve=ecdsa.SECP256k1
    ).verifying_key.to_string('compressed')

    return h160 == hashlib.new(
        'ripemd160', hashlib.sha256(pub_key).digest()).digest()

def gen_subproducts(factors, seen: set, idx=0, prod=1):
    if idx == len(factors):
        if prod > 1 and prod not in seen:
            seen.add(prod)
            if match(prod):
                print(f'Key found: {hex(prod)}')
                with open("foundkey.txt", "w") as f:
                    f.write(f"Private key: {hex(prod)}")
                exit()
        return

    factor, exp = factors[idx]
    for i in range(exp + 1):
        if gen_subproducts(factors, seen, idx + 1, prod * (factor ** i)):
            return True

def generate_n():
    rand_divisor = random.randint(min_range, max_range)
    return (var_hash160dec // rand_divisor) * rand_divisor

# Decode target H160
h160 = base58.b58decode_check(addr)[1:]
print(f'Target H160: {h160.hex():>040s}')

while True:
    n = generate_n()
    print(f'Trying n = {n}')
   
    factors = list(sympy.factorint(n).items())
    seen = set()
   
    if gen_subproducts(factors, seen):
        break

[dastic]

useless_shenanigans part 2:

Code:

import hashlib
import time
import sympy
import ecdsa
import base58
import random

# Given constants
var_hash160dec = 1282931445580409769159733555522242769745473092945
min_range = 242965459430942930354
max_range = 276313659744993920795
addr = '1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ'

def match(pk):
    pub_key = ecdsa.SigningKey.from_string(
        pk.to_bytes(32, 'big'), curve=ecdsa.SECP256k1
    ).verifying_key.to_string('compressed')

    return h160 == hashlib.new(
        'ripemd160', hashlib.sha256(pub_key).digest()).digest()

def gen_subproducts(factors, seen: set, idx=0, prod=1):
    if idx == len(factors):
        if prod > 1 and prod not in seen:
            seen.add(prod)
            if match(prod):
                print(f'Key found: {hex(prod)}')
                with open("foundkey.txt", "w") as f:
                    f.write(f"Private key: {hex(prod)}")
                exit()
        return

    factor, exp = factors[idx]
    for i in range(exp + 1):
        if gen_subproducts(factors, seen, idx + 1, prod * (factor ** i)):
            return True

def generate_n():
    rand_divisor = random.randint(min_range, max_range)
    return (var_hash160dec // rand_divisor) * rand_divisor

# Decode target H160
h160 = base58.b58decode_check(addr)[1:]
print(f'Target H160: {h160.hex():>040s}')

while True:
    n = generate_n()
    print(f'Trying n = {n}')
    
    factors = list(sympy.factorint(n).items())
    seen = set()
    
    if gen_subproducts(factors, seen):
        break

Why you chose this range?

min_range = 242965459430942930354
max_range = 276313659744993920795

[frozenen]

useless_shenanigans part 2:

Code:

import hashlib
import time
import sympy
import ecdsa
import base58
import random

# Given constants
var_hash160dec = 1282931445580409769159733555522242769745473092945
min_range = 242965459430942930354
max_range = 276313659744993920795
addr = '1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ'

def match(pk):
    pub_key = ecdsa.SigningKey.from_string(
        pk.to_bytes(32, 'big'), curve=ecdsa.SECP256k1
    ).verifying_key.to_string('compressed')

    return h160 == hashlib.new(
        'ripemd160', hashlib.sha256(pub_key).digest()).digest()

def gen_subproducts(factors, seen: set, idx=0, prod=1):
    if idx == len(factors):
        if prod > 1 and prod not in seen:
            seen.add(prod)
            if match(prod):
                print(f'Key found: {hex(prod)}')
                with open("foundkey.txt", "w") as f:
                    f.write(f"Private key: {hex(prod)}")
                exit()
        return

    factor, exp = factors[idx]
    for i in range(exp + 1):
        if gen_subproducts(factors, seen, idx + 1, prod * (factor ** i)):
            return True

def generate_n():
    rand_divisor = random.randint(min_range, max_range)
    return (var_hash160dec // rand_divisor) * rand_divisor

# Decode target H160
h160 = base58.b58decode_check(addr)[1:]
print(f'Target H160: {h160.hex():>040s}')

while True:
    n = generate_n()
    print(f'Trying n = {n}')
    
    factors = list(sympy.factorint(n).items())
    seen = set()
    
    if gen_subproducts(factors, seen):
        break

Why you chose this range?

min_range = 242965459430942930354
max_range = 276313659744993920795

Cause I think #68 is inside that range, may not be!

[vincetcm]

Exactly and You have readed my first post correctly so in order to get the private key I need that decimal hash160 string and a range boundary, optionally You can provide the initial address You have got in the first step.
Then I will provide results almost immediately.

Okay, let's do this.

decimal hash160 string:

Code:

1282931445580409769159733555426437642907293617404

range boundary:

Code:

80000000000000000:fffffffffffffffff

Pls give me the private key immediately.  

I need to clarify something once again - Yes, You have readed my first post correctly but You did not do the steps I ask for.
That would be simply too easy to give something I also want

I have already provided the two parameters you need, and now you’re asking me for extra information.

Alright, you say that everything must be done exactly according to your steps, but the whole process is predicated on the fact that I need to know the private key.

Without the private key, I wouldn’t be able to get the string mentioned in step 6.

So, since I already know the private key, why do we have to engage in these tedious number transformation games?

Stop playing your number games—it's like saying that your birth year plus your age equals the current year.

That's why I wrote it is just a TEST to show You that there is another interesting approach available that looks like You are not familiar with.
Of course having a private key makes whole "decode" process useless but that is just only to show You that even though I don't know Your pvk but I have enough data of Your choice I am able to do what I say.

Your approach is very absurd. It's no different from saying, "Add the private key to the ripemd160 value and give me the new value." I can derive the result using subtraction. You're using division; that's the only difference.

[jasperr]

Is anyone's slipstream like this since the past week??

https://i.ibb.co/fY0cZvwL/IMG-20250305-100859.jpg

Also, is it possible to try out Testnet txs on slipstream??