Bitcoin puzzle transaction ~32 BTC prize to who solves it

[pbies]

All these puzzle pvks could be generated this way:

(Python 3 script)

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys, base58, random

from hdwallet import HDWallet
from hdwallet.cryptocurrencies import Bitcoin as BTC
from hdwallet.hds import BIP32HD

_hdwallet = HDWallet(cryptocurrency=BTC, hd=BIP32HD)

def pvk_to_wif2(key_hex: str) -> str:
	return base58.b58encode_check(b'\x80' + bytes.fromhex(key_hex)).decode()

def go(key_hex: str):
	_hdwallet.from_private_key(private_key=key_hex)
	wif = pvk_to_wif2(key_hex)
	out = (
		f"{key_hex}\n"
		f"{wif}\n"
		f"{_hdwallet.wif()}\n"
		f"{_hdwallet.address('P2PKH')}\n"
		f"{_hdwallet.address('P2SH')}\n"
		f"{_hdwallet.address('P2TR')}\n"
		f"{_hdwallet.address('P2WPKH')}\n"
		f"{_hdwallet.address('P2WPKH-In-P2SH')}\n"
		f"{_hdwallet.address('P2WSH')}\n"
		f"{_hdwallet.address('P2WSH-In-P2SH')}\n"
		f"\n"
	)
	return out

def gen():
	for i in range(0,256):
		j=2**i
		r=random.randint(j,j*2)
		yield hex(r)[2:].zfill(64)

def main():
	o = open('output.txt', 'w')

	for s in tqdm(range(0, 2049)):
		random.seed(s)
		with Pool(cpu_count()) as pool:
			for res in pool.imap_unordered(go, gen()):
				o.write("".join(res))

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

[skedarve]

The truth is that I have a pattern and im willing to share it with someone who has a Voucher and can implement it in CUDA.

[snaz3d]

The truth is that I have a pattern and im willing to share it with someone who has a Voucher and can implement it in CUDA.

If there was one you wouldn't need a GPU implementation

[optioncmdPR]

                                       I think its time jump outside of the brute force box .
We can start here:


   Advanced Quadrilatic Axioconvergence Vector-point Enumerator
 - boundary limited scalar producer for elliptic curve point discovery -

 direction of vector slope set:
(u,v,w,z)
is purely a rule for how you move through the
quadrilateral (4‑square rooted integer)lattice:

(a,b,c,d)\rightarrow(a+u,\;b+v,\;c+w,\;d+z)
Every step produces a new 4‑tuple ,which produces a new scalar:

The scalar value itself is the EC private key that derives the pubkey,
of which is then  HASH160 'd
The vectors are the direction of the path you blaze in scalar space


5 use  examples of direction vectors, each chosen for a different
search behavior:


1.
Speedy Dense Local Walk (slow scalar drift) ( think asian shuffle)
These keep you in a tight scalar band and explore it thoroughly.
(1,1,1,1)
(2,1,0,1)
(3,2,1,0)
(1,0,0,0)  pure 1‑D walk
Behavior:
Small changes in (a,b,c,d)
Scalar k= a^2 + b^2 + c^2 + d^2
grows slowly
Good for narrow band search (e.g.,2130)

2.
Wide Scatter Walk (fast scalar drift)
These jump through scalar space aggressively.
(10_000,7,3,1)
(500_000,1000,10,1)
(2_000_000,1,1,1)
(100_000,100_000,100_000,100_000)
Behavior:
Large jumps in the 4‑square sum
Covers huge scalar ranges quickly
Good for broad exploration or randomized coverage

3.
Orthogonal/ Mixed Sign Vectors (cycle‑resistant)
These reduce repetition and avoid short loops.
(1,1,2,3)
(5,7,11,13)
(17,19,23,29)
(3,5,7,11)
Behavior:
Mixed signs prevent monotonic drift
Coprime components reduce periodicity
Excellent for long unique paths

4.
Pseudo‑Random Deterministic Vectors
Seeded from a passphrase, timestamp, etc

(27472219626,12597847844,6088408955,4465381162)←yourexample
(918273645,564738291,1029384756,675849302)
(123456789,987654321,192837465,564738291)
Behavior:
Looks random but fully reproducible
..for deterministic walks

5.Multi‑Ray (thread) SwarmVectors for parallel search.
Launches several rays from the same starting point.

(1,1,1,1)
(2,1,3,5)
(5,3,2,1)
(7,3,11,5)
(13,2,7,3)
(17,19,23,29)
(101,103,107,109)
(10000,7,3,1)


Behavior:
Each ray explores a different region
Maximizes coverage
Ideal for parallel CPU/GPU search


None of these vectors have any relationship to the target HASH160.
They only determine which scalars you will test.
The target HASH160 simply tells you when you hit the  correct scalar for it.
But hey, thats the ultimate goal anyway.

Code:

from ecdsa import SigningKey, VerifyingKey, SECP256k1
from ecdsa.util import number_to_string
from hashlib import sha256, new as hashlib_new
from binascii import unhexlify, hexlify

# helpers

def hash160(b: bytes) -> bytes:
    h = hashlib_new('ripemd160')
    h.update(sha256(b).digest())
    return h.digest()

def priv_to_pub_compressed(priv_int: int) -> bytes:
    sk = SigningKey.from_secret_exponent(priv_int, curve=SECP256k1)
    vk = sk.verifying_key
    x = vk.pubkey.point.x()
    y = vk.pubkey.point.y()
    prefix = b'\x02' if y % 2 == 0 else b'\x03'
    return prefix + number_to_string(x, SECP256k1.order)

def decompress_pubkey(comp: bytes):
    prefix = comp[0]
    x = int.from_bytes(comp[1:], "big")
    curve = SECP256k1.curve
    p = curve.p()

    y_sq = (x * x * x + 7) % p
    y = pow(y_sq, (p + 1) // 4, p)
    if (y % 2) != (prefix % 2):
        y = (-y) % p

    return curve.point(x, y)

def compress_point(P):
    x = P.x()
    y = P.y()
    prefix = b'\x02' if y % 2 == 0 else b'\x03'
    return prefix + number_to_string(x, SECP256k1.order)

def halve_pubkey(comp: bytes) -> bytes:
    P = decompress_pubkey(comp)
    n = SECP256k1.order
    inv2 = (n + 1) // 2
    halfP = P * inv2
    return compress_point(halfP)

#quadrilatics logic

def four_square_scalar(a, b, c, d, order):
    return (a*a + b*b + c*c + d*d) % order

def walk_four_square_ray(
    a0, b0, c0, d0,
    u, v, w, z,
    steps,
    target_hash160_hex=None,
    low_bound=None,
    high_bound=None,
):
    order = SECP256k1.order
    target_hash = None
    if target_hash160_hex:
        target_hash = unhexlify(target_hash160_hex.strip())

    a, b, c, d = a0, b0, c0, d0

    print("\nAdvanced Quadrilatic Axioconvergence Vector-point Enumerator")
    print(f"Start (a,b,c,d) = ({a0}, {b0}, {c0}, {d0})")
    print(f"Direction (u,v,w,z) = ({u}, {v}, {w}, {z})")
    print(f"Steps: {steps}")
    if target_hash is not None:
        print(f"Target HASH160: {target_hash160_hex}")
    if low_bound is not None or high_bound is not None:
        print(f"Scalar band filter: [{low_bound}, {high_bound}]")

    for i in range(steps):
        k = four_square_scalar(a, b, c, d, order)
        if k == 0:
            a += u; b += v; c += w; d += z
            continue

        if low_bound is not None and k < low_bound:
            a += u; b += v; c += w; d += z
            continue
        if high_bound is not None and k > high_bound:
            a += u; b += v; c += w; d += z
            continue

        pub = priv_to_pub_compressed(k)
        h = hash160(pub)

        # Show first few steps for sanity
        if i < 5:
            print(f"\nStep {i}")
            print(f"  (a,b,c,d) = ({a}, {b}, {c}, {d})")
            print(f"  scalar k  = {k}")
            print(f"  pub       = {hexlify(pub).decode()}")
            print(f"  HASH160   = {hexlify(h).decode()}")

        if target_hash is not None and h == target_hash:
            print("\n success ")
            print(f"Step: {i}")
            print(f"(a,b,c,d) = ({a}, {b}, {c}, {d})")
            print(f"scalar k   = {k}")
            print(f"pub        = {hexlify(pub).decode()}")
            print (f"HASH160 = {hexlify (h).decode ()}")
            return  # stop on first match

        a += u; b += v; c += w; d += z

    print("\nWalk is a complete failure ")

#main prompt engine

def read_tuple(prompt, count, default=None):
    s = input(prompt).strip()
    if s == "":
        if default is None:
            raise ValueError("No value provided for required tuple")
        return default
    parts = [p.strip() for p in s.split(",")]
    if len(parts) != count:
        raise ValueError(f"Expected {count} comma-separated values")
    return tuple(int(p) for p in parts)

def read_int(prompt, default=None):
    s = input(prompt).strip()
    if s == "":
        return default
    return int(s)

def main():
    print(" START ")

    print("\nEnter starting 4-square coordinates (a0, b0, c0, d0).")
    a0, b0, c0, d0 = read_tuple(
        "a0,b0,c0,d0 (comma sep, default 0,0,0,0): ",
        4,
        default=(0,0,0,0)
    )

    print("\nEnter direction vector (u, v, w, z).")
    u, v, w, z = read_tuple(
        "u,v,w,z (comma-separated, default 1,0,0,0): ",
        4,
        default=(1,0,0,0)
    )

    steps = read_int("\nNumber of steps (default 10): ", 10)

    target_hex = input("\nTarget HASH160 hex (optional, blank for none): ").strip()
    if target_hex == "":
        target_hex = None

    low_s = input("Low scalar bound (optional, blank for none): ").strip()
    high_s = input("High scalar bound (optional, blank for none): ").strip()
    low_bound = int(low_s) if low_s else None
    high_bound = int(high_s) if high_s else None

    walk_four_square_ray(
        a0, b0, c0, d0,
        u, v, w, z,
        steps,
        target_hash160_hex=target_hex,
        low_bound=low_bound,
        high_bound=high_bound,
    )

    print("\n end ")

if __name__ == "__main__":
    main()

[kTimesG]

  Advanced Quadrilatic Axioconvergence Vector-point Enumerator
 - boundary limited scalar producer for elliptic curve point discovery -

You've got too much free time.

[skedarve]

  Advanced Quadrilatic Axioconvergence Vector-point Enumerator
 - boundary limited scalar producer for elliptic curve point discovery -

You've got too much free time.

What do you think of my research? I dont know if you were able to see it, since I had to delete it.

[optioncmdPR]

  Advanced Quadrilatic Axioconvergence Vector-point Enumerator
 - boundary limited scalar producer for elliptic curve point discovery -

You've got too much free time.

guilty as charged, sir.

[skedarve]

  Advanced Quadrilatic Axioconvergence Vector-point Enumerator
 - boundary limited scalar producer for elliptic curve point discovery -

You've got too much free time.

guilty as charged, sir.

Im use  : 1x GPU T4

Iniciando búsqueda continua. Presiona Ctrl+C para detener.
Rango: 0x4002160ebffffffe - 0xffffffffffffffff
Claves por lanzamiento: 8388608000000
Reportes cada 60 segundos.

[ 174.8 s] Procesadas: 8388608000000 | Vel: 4.80e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40021dafdffffffd
[ 355.7 s] Procesadas: 16777216000000 | Vel: 4.72e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40022550fffffffd
[ 536.7 s] Procesadas: 25165824000000 | Vel: 4.69e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40022cf21ffffffd
[ 718.2 s] Procesadas: 33554432000000 | Vel: 4.67e+10 keys/s | Candidatas acum: 0 | Última clave: 0x400234933ffffffd
[ 900.3 s] Procesadas: 41943040000000 | Vel: 4.66e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40023c345ffffffd
[1081.7 s] Procesadas: 50331648000000 | Vel: 4.65e+10 keys/s | Candidatas acum: 0 | Última clave: 0x400243d57ffffffd
[1263.1 s] Procesadas: 58720256000000 | Vel: 4.65e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40024b769ffffffd
[1444.2 s] Procesadas: 67108864000000 | Vel: 4.65e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40025317bffffffd

[optioncmdPR]

  I don't want to engage in polemics with some forum members who believe that the only way to solve problems is brute force. Given the current state of computing power, this approach would take millennia or entail financial costs exceeding the prize. Essentially, they are suggesting to wait for technological progress or embark on a thousand-year journey. Any other approaches seem to offend them (apparently, they have already started down this path) and they react hysterically to such a position. Moreover, they promote this vision aggressively and tactlessly, insulting other opinions and approaches, much like an aggressive LGBT community. I think even monkey could solve it with a powerful GPU and the right program.
  Continuing to develop alternative approaches to problem-solving, I'm sharing one line of thought on how the task could be solved. Below is a list of private keys with their prime multipliers.
 1 -> 1
3 -> 3
7 -> 7
8 -> 2, 2, 2
21 -> 3, 7
49 -> 7, 7
76 -> 2, 2, 19
224 -> 2, 2, 2, 2, 2, 7
467 -> 467
514 -> 2, 257
1155 -> 3, 5, 7, 11
2683 -> 2683
5216 -> 2, 2, 2, 2, 2, 163
10544 -> 2, 2, 2, 2, 659
26867 -> 67, 401
51510 -> 2, 3, 5, 17, 101
95823 -> 3, 3, 3, 3, 7, 13, 13
198669 -> 3, 47, 1409
357535 -> 5, 23, 3109
863317 -> 7, 13, 53, 179
1811764 -> 2, 2, 19, 31, 769
3007503 -> 3, 3, 3, 23, 29, 167
5598802 -> 2, 11, 254491
14428676 -> 2, 2, 19, 189851
33185509 -> 7, 4740787
54538862 -> 2, 7, 7, 556519
111949941 -> 3, 43, 867829
227634408 -> 2, 2, 2, 3, 3, 3, 1053863
400708894 -> 2, 83, 2413909
1033162084 -> 2, 2, 47, 5495543
2102388551 -> 19, 19, 43, 167, 811
3093472814 -> 2, 23, 3001, 22409
7137437912 -> 2, 2, 2, 11, 751, 107999
14133072157 -> 19, 41, 131, 138493
20112871792 -> 2, 2, 2, 2, 13, 96696499
42387769980 -> 2, 2, 3, 3, 5, 235487611
100251560595 -> 3, 5, 6683437373
146971536592 -> 2, 2, 2, 2, 60037, 153001
323724968937 -> 3, 3, 138319, 260047
1003651412950 -> 2, 5, 5, 20073028259
1458252205147 -> 23, 63402269789
2895374552463 -> 3, 3, 59, 5452682773
7409811047825 -> 5, 5, 587, 2903, 173933
15404761757071 -> 2783789, 5533739
19996463086597 -> 157, 193, 7477, 88261
51408670348612 -> 2, 2, 5839, 2201090527
119666659114170 -> 2, 3, 3, 3, 5, 7, 17, 89, 41847781
191206974700443 -> 3, 13, 4902742941037
409118905032525 -> 3, 3, 5, 5, 23, 197, 1663, 241313
611140496167764 -> 2, 2, 3, 3, 12211, 1390232159
2058769515153876 -> 2, 2, 3, 7, 43, 53, 197, 2477, 22039
4216495639600700 -> 2, 2, 5, 5, 53, 795565215019
6763683971478124 -> 2, 2, 14359547, 117755873
9974455244496707 -> 7019, 76123, 18668011
30045390491869460 -> 2, 2, 5, 19, 79066817083867
44218742292676575 -> 3, 3, 5, 5, 13, 15117518732539
138245758910846492 -> 2, 2, 23, 1002377, 1499107913
199976667976342049 -> 13, 167, 2511323, 36678953
525070384258266191 -> 307, 307, 5571097669559
1135041350219496382 -> 2, 13, 31, 71, 269, 587, 3637, 34537
1425787542618654982 -> 2, 13, 54837982408409807
3908372542507822062 -> 2, 3, 43, 62922991, 240750329
8993229949524469768 -> 2, 2, 2, 7, 251, 2383, 268491108091
17799667357578236628 -> 2, 2, 3, 19, 3761, 408229, 50847529
30568377312064202855 -> 5, 67, 5639, 16181749866767
46346217550346335726 -> 2, 13, 17, 104855695815263203
132656943602386256302 -> 2, 23, 3881, 743067920652377
219898266213316039825 -> 5, 5, 7, 1973, 4986139, 127729817
297274491920375905804 -> 2, 2, 11, 139, 48606032034070619
970436974005023690481 -> 3, 59, 1931, 255473, 11113907731

As you can see from the list, these keys do not correspond to the generation of secure RSA keys, which typically have two or three small prime factors and one large factor exceeding the value of sqrt(private key).

For example, puzzle #68 is cryptographically weak (I think whoever created the puzzles intentionally made them vulnerable, or they follow certain patterns which consequently made them insecure.):
219898266213316039825 -> 5, 5, 7, 1973, 4986139, 127729817
since its greatest prime divisor < sqrt(private key).

That is, we would first find the largest possible value for the Greatest Prime Divisor (GPD) that is < 2^34. Then, using the Miller-Rabin Primality Test, we would check each prime number in descending order within the range where:
2^67 < Private Key = GPD * number < 2^68
and consequently,
2^67 / GPD < number < 2^68 / GPD.

But given approach will not wrok if private key is a prime number as puzzle number 12, or GPD of a key is GPD>sqrt(private key).

Currently, I have a simple program written in Python that checks 5000 prime numbers per second. I think if it were optimized for a GPU, it could solve the vulnerable keys among the subsequent ones in a few hours.

I feel that your research is meaningless, as the private key of Bitcoin has nothing to do with the RSA encryption you mentioned.
The private key of Bitcoin does not need to meet the requirements of RSA keys at all.

  Why are so sure that the keys were generated using anything related to bitcoin at all?

[kTimesG]

Why are so sure that the keys were generated using anything related to bitcoin at all?

Private keys are scalar numbers.

The creator stated that the private keys are consecutive keys from a deterministic wallet, masked accordingly. Basically, random numbers, unless you know the master seed.

A deterministic wallet is something that is related to Bitcoin.

And yeah, breaking the seed is harder then finding all the 256 private keys, combined.

[pbies]

I've made two scripts in python with prime numbers to eventually hit all puzzle:

Generate primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys

MAX_B = 1_000_000_000
CHUNK_SIZE = 1_000_000

def worker(args):
	start_x, end_x = args
	out = []

	for x in range(start_x, end_x):
		a = (x * 6) - 1
		b = (x * 6) + 1

		if a % 5 != 0:
			out.append(f"{a}\n")

		if b % 5 != 0:
			out.append(f"{b}\n")

		if b > MAX_B:
			break

	return "".join(out)

def generate_ranges():
	max_x = (MAX_B // 6) + 2
	for start in range(2, max_x, CHUNK_SIZE):
		end = min(start + CHUNK_SIZE, max_x)
		yield (start, end)

def main():
	with Pool(cpu_count()) as pool, open("primes02.txt", "w") as o:
		total_chunks = ((MAX_B // 6) + 2 + CHUNK_SIZE - 1) // CHUNK_SIZE

		for result in tqdm(
			pool.imap_unordered(worker, generate_ranges(), chunksize=1),
			total=total_chunks
		):
			o.write(result)

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

Search with these primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys, base58, random
import itertools, math, time
from itertools import combinations

from hdwallet import HDWallet
from hdwallet.cryptocurrencies import Bitcoin as BTC
from hdwallet.hds import BIP32HD
from hdwallet.seeds import BIP39Seed

_hdwallet = HDWallet(cryptocurrency=BTC, hd=BIP32HD)

class Timer:
	def __enter__(self):
		self.start = time.perf_counter()
	def __exit__(self, type, value, traceback):
		self.end = time.perf_counter()
		print(f"This took: {self.end - self.start: .5f} seconds")

def pvk_to_wif2(key_hex):
	return base58.b58encode_check(b'\x80' + bytes.fromhex(key_hex)).decode()

targets=set()

def go(key_hex):
	_hdwallet.from_private_key(key_hex)
	t=_hdwallet.address('P2PKH')
	if t in targets:
		wif1 = pvk_to_wif2(key_hex)
		wif2 = _hdwallet.wif()
		line = f'{key_hex} {wif1} {wif2} {t}\n'
		with open('found.txt', 'a') as o:
			o.write(line)
			o.flush()

primes=set()

def gen():
	global primes
	for r in range(1, 6):
		i=itertools.product(primes, repeat=r)
		for j in i:
			k=math.prod(j)
			if k>=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140:
				continue
			yield hex(k)[2:].zfill(64)

def main():
	global primes, targets
	print('Loading targets...', flush=True)
	targets=set(open('input.txt','r').read().splitlines())
	print('Loading primes...', flush=True)
	with Timer():
		primes_src=set(open('primes02.txt','r').read().splitlines())
	print('Converting primes...', flush=True)
	with Timer():
		primes = set( int(x) for x in primes_src )

	print('Starting search...', flush=True)
	tmp=0
	for r in range(1, 6):
		tmp+=len(primes)**r
	t=tqdm(total=tmp)
	with Pool(cpu_count()) as pool:
		for res in pool.imap_unordered(go, gen()):
			t.update()

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

In input.txt file you need unhit puzzle addresses:

Code:

1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU
1JTK7s9YVYywfm5XUH7RNhHJH1LshCaRFR
12VVRNPi4SJqUTsp6FmqDqY5sGosDtysn4
1FWGcVDK3JGzCC3WtkYetULPszMaK2Jksv
1DJh2eHFYQfACPmrvpyWc8MSTYKh7w9eRF
1Bxk4CQdqL9p22JEtDfdXMsng1XacifUtE
15qF6X51huDjqTmF9BJgxXdt1xcj46Jmhb
1ARk8HWJMn8js8tQmGUJeQHjSE7KRkn2t8
15qsCm78whspNQFydGJQk5rexzxTQopnHZ
13zYrYhhJxp6Ui1VV7pqa5WDhNWM45ARAC
14MdEb4eFcT3MVG5sPFG4jGLuHJSnt1Dk2
1CMq3SvFcVEcpLMuuH8PUcNiqsK1oicG2D
1K3x5L6G57Y494fDqBfrojD28UJv4s5JcK
1PxH3K1Shdjb7gSEoTX7UPDZ6SH4qGPrvq
16AbnZjZZipwHMkYKBSfswGWKDmXHjEpSf
19QciEHbGVNY4hrhfKXmcBBCrJSBZ6TaVt
1EzVHtmbN4fs4MiNk3ppEnKKhsmXYJ4s74
1AE8NzzgKE7Yhz7BWtAcAAxiFMbPo82NB5
17Q7tuG2JwFFU9rXVj3uZqRtioH3mx2Jad
1K6xGMUbs6ZTXBnhw1pippqwK6wjBWtNpL
15ANYzzCp5BFHcCnVFzXqyibpzgPLWaD8b
18ywPwj39nGjqBrQJSzZVq2izR12MDpDr8
1CaBVPrwUxbQYYswu32w7Mj4HR4maNoJSX
1JWnE6p6UN7ZJBN7TtcbNDoRcjFtuDWoNL
1CKCVdbDJasYmhswB6HKZHEAnNaDpK7W4n
1PXv28YxmYMaB8zxrKeZBW8dt2HK7RkRPX
1AcAmB6jmtU6AiEcXkmiNE9TNVPsj9DULf
1EQJvpsmhazYCcKX5Au6AZmZKRnzarMVZu
18KsfuHuzQaBTNLASyj15hy4LuqPUo1FNB
15EJFC5ZTs9nhsdvSUeBXjLAuYq3SWaxTc
1HB1iKUqeffnVsvQsbpC6dNi1XKbyNuqao
1GvgAXVCbA8FBjXfWiAms4ytFeJcKsoyhL
1824ZJQ7nKJ9QFTRBqn7z7dHV5EGpzUpH3
18A7NA9FTsnJxWgkoFfPAFbQzuQxpRtCos
1NeGn21dUDDeqFQ63xb2SpgUuXuBLA4WT4
174SNxfqpdMGYy5YQcfLbSTK3MRNZEePoy
1MnJ6hdhvK37VLmqcdEwqC3iFxyWH2PHUV
1KNRfGWw7Q9Rmwsc6NT5zsdvEb9M2Wkj5Z
1PJZPzvGX19a7twf5HyD2VvNiPdHLzm9F6
1GuBBhf61rnvRe4K8zu8vdQB3kHzwFqSy7
1GDSuiThEV64c166LUFC9uDcVdGjqkxKyh
1Me3ASYt5JCTAK2XaC32RMeH34PdprrfDx
1CdufMQL892A69KXgv6UNBD17ywWqYpKut
1BkkGsX9ZM6iwL3zbqs7HWBV7SvosR6m8N
1AWCLZAjKbV1P7AHvaPNCKiB7ZWVDMxFiz
1G6EFyBRU86sThN3SSt3GrHu1sA7w7nzi4
1MZ2L1gFrCtkkn6DnTT2e4PFUTHw9gNwaj
1Hz3uv3nNZzBVMXLGadCucgjiCs5W9vaGz
16zRPnT8znwq42q7XeMkZUhb1bKqgRogyy
1KrU4dHE5WrW8rhWDsTRjR21r8t3dsrS3R
17uDfp5r4n441xkgLFmhNoSW1KWp6xVLD
13A3JrvXmvg5w9XGvyyR4JEJqiLz8ZySY3
16RGFo6hjq9ym6Pj7N5H7L1NR1rVPJyw2v
1UDHPdovvR985NrWSkdWQDEQ1xuRiTALq
15nf31J46iLuK1ZkTnqHo7WgN5cARFK3RA
1Ab4vzG6wEQBDNQM1B2bvUz4fqXXdFk2WT
1Fz63c775VV9fNyj25d9Xfw3YHE6sKCxbt
1QKBaU6WAeycb3DbKbLBkX7vJiaS8r42Xo
1CD91Vm97mLQvXhrnoMChhJx4TP9MaQkJo
15MnK2jXPqTMURX4xC3h4mAZxyCcaWWEDD
13N66gCzWWHEZBxhVxG18P8wyjEWF9Yoi1
1NevxKDYuDcCh1ZMMi6ftmWwGrZKC6j7Ux
19GpszRNUej5yYqxXoLnbZWKew3KdVLkXg
1M7ipcdYHey2Y5RZM34MBbpugghmjaV89P
18aNhurEAJsw6BAgtANpexk5ob1aGTwSeL
1FwZXt6EpRT7Fkndzv6K4b4DFoT4trbMrV
1CXvTzR6qv8wJ7eprzUKeWxyGcHwDYP1i2
1MUJSJYtGPVGkBCTqGspnxyHahpt5Te8jy
13Q84TNNvgcL3HJiqQPvyBb9m4hxjS3jkV
1LuUHyrQr8PKSvbcY1v1PiuGuqFjWpDumN
18192XpzzdDi2K11QVHR7td2HcPS6Qs5vg
1NgVmsCCJaKLzGyKLFJfVequnFW9ZvnMLN
1AoeP37TmHdFh8uN72fu9AqgtLrUwcv2wJ
1FTpAbQa4h8trvhQXjXnmNhqdiGBd1oraE
14JHoRAdmJg3XR4RjMDh6Wed6ft6hzbQe9
19z6waranEf8CcP8FqNgdwUe1QRxvUNKBG
14u4nA5sugaswb6SZgn5av2vuChdMnD9E5
1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv

[skedarve]

I've made two scripts in python with prime numbers to eventually hit all puzzle:

Generate primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys

MAX_B = 1_000_000_000
CHUNK_SIZE = 1_000_000

def worker(args):
	start_x, end_x = args
	out = []

	for x in range(start_x, end_x):
		a = (x * 6) - 1
		b = (x * 6) + 1

		if a % 5 != 0:
			out.append(f"{a}\n")

		if b % 5 != 0:
			out.append(f"{b}\n")

		if b > MAX_B:
			break

	return "".join(out)

def generate_ranges():
	max_x = (MAX_B // 6) + 2
	for start in range(2, max_x, CHUNK_SIZE):
		end = min(start + CHUNK_SIZE, max_x)
		yield (start, end)

def main():
	with Pool(cpu_count()) as pool, open("primes02.txt", "w") as o:
		total_chunks = ((MAX_B // 6) + 2 + CHUNK_SIZE - 1) // CHUNK_SIZE

		for result in tqdm(
			pool.imap_unordered(worker, generate_ranges(), chunksize=1),
			total=total_chunks
		):
			o.write(result)

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

Search with these primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys, base58, random
import itertools, math, time
from itertools import combinations

from hdwallet import HDWallet
from hdwallet.cryptocurrencies import Bitcoin as BTC
from hdwallet.hds import BIP32HD
from hdwallet.seeds import BIP39Seed

_hdwallet = HDWallet(cryptocurrency=BTC, hd=BIP32HD)

class Timer:
	def __enter__(self):
		self.start = time.perf_counter()
	def __exit__(self, type, value, traceback):
		self.end = time.perf_counter()
		print(f"This took: {self.end - self.start: .5f} seconds")

def pvk_to_wif2(key_hex):
	return base58.b58encode_check(b'\x80' + bytes.fromhex(key_hex)).decode()

targets=set()

def go(key_hex):
	_hdwallet.from_private_key(key_hex)
	t=_hdwallet.address('P2PKH')
	if t in targets:
		wif1 = pvk_to_wif2(key_hex)
		wif2 = _hdwallet.wif()
		line = f'{key_hex} {wif1} {wif2} {t}\n'
		with open('found.txt', 'a') as o:
			o.write(line)
			o.flush()

primes=set()

def gen():
	global primes
	for r in range(1, 6):
		i=itertools.product(primes, repeat=r)
		for j in i:
			k=math.prod(j)
			if k>=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140:
				continue
			yield hex(k)[2:].zfill(64)

def main():
	global primes, targets
	print('Loading targets...', flush=True)
	targets=set(open('input.txt','r').read().splitlines())
	print('Loading primes...', flush=True)
	with Timer():
		primes_src=set(open('primes02.txt','r').read().splitlines())
	print('Converting primes...', flush=True)
	with Timer():
		primes = set( int(x) for x in primes_src )

	print('Starting search...', flush=True)
	tmp=0
	for r in range(1, 6):
		tmp+=len(primes)**r
	t=tqdm(total=tmp)
	with Pool(cpu_count()) as pool:
		for res in pool.imap_unordered(go, gen()):
			t.update()

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

In input.txt file you need unhit puzzle addresses:

Code:

1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU
1JTK7s9YVYywfm5XUH7RNhHJH1LshCaRFR
12VVRNPi4SJqUTsp6FmqDqY5sGosDtysn4
1FWGcVDK3JGzCC3WtkYetULPszMaK2Jksv
1DJh2eHFYQfACPmrvpyWc8MSTYKh7w9eRF
1Bxk4CQdqL9p22JEtDfdXMsng1XacifUtE
15qF6X51huDjqTmF9BJgxXdt1xcj46Jmhb
1ARk8HWJMn8js8tQmGUJeQHjSE7KRkn2t8
15qsCm78whspNQFydGJQk5rexzxTQopnHZ
13zYrYhhJxp6Ui1VV7pqa5WDhNWM45ARAC
14MdEb4eFcT3MVG5sPFG4jGLuHJSnt1Dk2
1CMq3SvFcVEcpLMuuH8PUcNiqsK1oicG2D
1K3x5L6G57Y494fDqBfrojD28UJv4s5JcK
1PxH3K1Shdjb7gSEoTX7UPDZ6SH4qGPrvq
16AbnZjZZipwHMkYKBSfswGWKDmXHjEpSf
19QciEHbGVNY4hrhfKXmcBBCrJSBZ6TaVt
1EzVHtmbN4fs4MiNk3ppEnKKhsmXYJ4s74
1AE8NzzgKE7Yhz7BWtAcAAxiFMbPo82NB5
17Q7tuG2JwFFU9rXVj3uZqRtioH3mx2Jad
1K6xGMUbs6ZTXBnhw1pippqwK6wjBWtNpL
15ANYzzCp5BFHcCnVFzXqyibpzgPLWaD8b
18ywPwj39nGjqBrQJSzZVq2izR12MDpDr8
1CaBVPrwUxbQYYswu32w7Mj4HR4maNoJSX
1JWnE6p6UN7ZJBN7TtcbNDoRcjFtuDWoNL
1CKCVdbDJasYmhswB6HKZHEAnNaDpK7W4n
1PXv28YxmYMaB8zxrKeZBW8dt2HK7RkRPX
1AcAmB6jmtU6AiEcXkmiNE9TNVPsj9DULf
1EQJvpsmhazYCcKX5Au6AZmZKRnzarMVZu
18KsfuHuzQaBTNLASyj15hy4LuqPUo1FNB
15EJFC5ZTs9nhsdvSUeBXjLAuYq3SWaxTc
1HB1iKUqeffnVsvQsbpC6dNi1XKbyNuqao
1GvgAXVCbA8FBjXfWiAms4ytFeJcKsoyhL
1824ZJQ7nKJ9QFTRBqn7z7dHV5EGpzUpH3
18A7NA9FTsnJxWgkoFfPAFbQzuQxpRtCos
1NeGn21dUDDeqFQ63xb2SpgUuXuBLA4WT4
174SNxfqpdMGYy5YQcfLbSTK3MRNZEePoy
1MnJ6hdhvK37VLmqcdEwqC3iFxyWH2PHUV
1KNRfGWw7Q9Rmwsc6NT5zsdvEb9M2Wkj5Z
1PJZPzvGX19a7twf5HyD2VvNiPdHLzm9F6
1GuBBhf61rnvRe4K8zu8vdQB3kHzwFqSy7
1GDSuiThEV64c166LUFC9uDcVdGjqkxKyh
1Me3ASYt5JCTAK2XaC32RMeH34PdprrfDx
1CdufMQL892A69KXgv6UNBD17ywWqYpKut
1BkkGsX9ZM6iwL3zbqs7HWBV7SvosR6m8N
1AWCLZAjKbV1P7AHvaPNCKiB7ZWVDMxFiz
1G6EFyBRU86sThN3SSt3GrHu1sA7w7nzi4
1MZ2L1gFrCtkkn6DnTT2e4PFUTHw9gNwaj
1Hz3uv3nNZzBVMXLGadCucgjiCs5W9vaGz
16zRPnT8znwq42q7XeMkZUhb1bKqgRogyy
1KrU4dHE5WrW8rhWDsTRjR21r8t3dsrS3R
17uDfp5r4n441xkgLFmhNoSW1KWp6xVLD
13A3JrvXmvg5w9XGvyyR4JEJqiLz8ZySY3
16RGFo6hjq9ym6Pj7N5H7L1NR1rVPJyw2v
1UDHPdovvR985NrWSkdWQDEQ1xuRiTALq
15nf31J46iLuK1ZkTnqHo7WgN5cARFK3RA
1Ab4vzG6wEQBDNQM1B2bvUz4fqXXdFk2WT
1Fz63c775VV9fNyj25d9Xfw3YHE6sKCxbt
1QKBaU6WAeycb3DbKbLBkX7vJiaS8r42Xo
1CD91Vm97mLQvXhrnoMChhJx4TP9MaQkJo
15MnK2jXPqTMURX4xC3h4mAZxyCcaWWEDD
13N66gCzWWHEZBxhVxG18P8wyjEWF9Yoi1
1NevxKDYuDcCh1ZMMi6ftmWwGrZKC6j7Ux
19GpszRNUej5yYqxXoLnbZWKew3KdVLkXg
1M7ipcdYHey2Y5RZM34MBbpugghmjaV89P
18aNhurEAJsw6BAgtANpexk5ob1aGTwSeL
1FwZXt6EpRT7Fkndzv6K4b4DFoT4trbMrV
1CXvTzR6qv8wJ7eprzUKeWxyGcHwDYP1i2
1MUJSJYtGPVGkBCTqGspnxyHahpt5Te8jy
13Q84TNNvgcL3HJiqQPvyBb9m4hxjS3jkV
1LuUHyrQr8PKSvbcY1v1PiuGuqFjWpDumN
18192XpzzdDi2K11QVHR7td2HcPS6Qs5vg
1NgVmsCCJaKLzGyKLFJfVequnFW9ZvnMLN
1AoeP37TmHdFh8uN72fu9AqgtLrUwcv2wJ
1FTpAbQa4h8trvhQXjXnmNhqdiGBd1oraE
14JHoRAdmJg3XR4RjMDh6Wed6ft6hzbQe9
19z6waranEf8CcP8FqNgdwUe1QRxvUNKBG
14u4nA5sugaswb6SZgn5av2vuChdMnD9E5
1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv

That was my research that I deleted; I think you copied it, but oh well.


The publication of the solved keys in the file bitcoin-puzzle-solved- provided 18 keys from puzzles #65 to #130. The analysis of these keys revealed deterministic patterns that allow for the construction of extremely selective modular filters. This report details the discovery process, the validation of the filters, and their implementation in a GPU attack that can solve puzzle #71 in a matter of days with sufficient hardware.

2. Starting Data: Private Keys from Puzzles #65 to #130
The 18 known keys (in hexadecimal) are:

Puzzle   Private Key (hex)
65   1a838b13505b26867
66   2832ed74f2b5e35ee
67   730fc235c1942c1ae
68   bebb3940cd0fc1491
69   101d83275fb2bc7e0c
70   349b84b6431a6c4ef1
75   4c5ce114686a1336e07
80   ea1a5c66dcc11b5ad180
85   11720c4f018d51b8cebba8
90   2ce00bb2136a445c71e85bf
95   527a792b183c7f64a0e8b1f4
100   af55fc59c335c8ec67ed24826
105   16f14fc2054cd87ee6396b33df3
110   35c0d7234df7deb0f20cf7062444
115   60f4d11574f5deee49961d9609ac6
120   b10f22572c497a836ea187f2e1fc23
125   1c533b6bb7f0804e09960225e44877ac
130   33e7665705359f04f28b88cf897c603c9
These 18 samples are the basis of the entire analysis.

3. First Biases: Modulo 910
Calculating the residues of the 18 keys modulo 910 revealed three constraints:

No residue ends in 0, 6, or 8 (last decimal digit).

No residue is congruent with 3 (modulo 7).

No residue is congruent with 3 or 6 (modulo 13).

Combining these three conditions using the Chinese Remainder Theorem yields a set of 462 allowed residues modulo 910. The probability that 18 random keys would satisfy this is less than 0.2%. This is a deliberate rule set by the creator.

4. Systematic Sweep of Moduli
A script was developed that, for each modulus m between 2 and 2000, calculated the residues of the 18 keys and measured the reduction. It was required that all 18 keys have their residue within the observed subset. Only a few moduli passed this test. Three stood out for their extremely high reduction:

Modulus   Size   Observed Residues
467   16   [10, 12, 31, 83, 202, 213, 226, 280, 283, 291, 292, 296, 378, 391, 438, 444]
491   16   [16, 25, 30, 102, 141, 162, 196, 228, 241, 284, 375, 392, 429, 462, 473, 490]
489   17   [34, 62, 99, 126, 136, 224, 245, 256, 268, 274, 280, 327, 388, 420, 438, 457, 459]
The probability that 18 random numbers in ranges of that size would fit into such small subsets is infinitesimal (on the order of 10⁻⁸⁰). These biases are real and deliberate.

5. Additional Filters from the Euclid Family
Numbers of the form M = k × pₙ# + 1 were explored, where pₙ# is the primorial (product of the first n primes). Many moduli (mostly primes) were found that also produce very small residue sets. Below is the complete list of the 27 moduli discovered, along with the size of their residue sets:

Modulus   Size   Approximate Fraction
910   462   0.508
467   16   0.0343
491   16   0.0326
489   17   0.0348
23   10   0.435
29   13   0.448
59   13   0.220
61   14   0.230
67   15   0.224
73   15   0.205
83   16   0.193
89   16   0.180
103   17   0.165
109   13   0.119
151   17   0.113
157   15   0.0955
173   17   0.0983
181   17   0.0939
199   17   0.0854
239   17   0.0711
241   16   0.0664
421   17   0.0404
601   17   0.0283
631   17   0.0269
1471   17   0.0116
2311   18   0.00779
200560490131   18   9.0×10⁻¹¹
The residue sets were obtained directly from the 18 keys, meaning all known keys pass all these filters.

6. Nibble Filter (bits 0-15)
Analyzing the 4 least significant bits of the 18 keys, it was observed that they never take the values {2, 5, 10, 11, 13}. Extending the analysis to the following nibbles (bits 4-7, 8-11, 12-15) revealed:

Nibble 1 (bits 4-7): forbidden values {1, 3, 5, 7, 13}

Nibble 2 (bits 8-11): forbidden value {1}

Nibble 3 (bits 12-15): forbidden value {15}

These filters are independent and are applied with simple bit comparisons. The probability that a key passes all four is:

(11/16)² × (15/16)² = 27225/65536 ≈ 0.4155

Speedup factor: 1 / 0.4155 ≈ 2.41×.

7. Cross-Validation
It was verified that all 18 known keys pass all the modular and nibble filters. It was also checked that puzzles prior to #65 (1-64) do not satisfy these filters, indicating that the creator changed their generation method starting from #65. This is irrelevant for #71, which belongs to the same group.

Furthermore, an extraordinary coincidence was discovered: the hash160 of the puzzle #71 address (f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8) is also an Ethereum address with funds. The probability of a random hash160 matching an existing ETH address is less than 2⁻¹⁶⁰. This demonstrates that the creator deliberately chooses keys with special properties, reinforcing the hypothesis that the patterns are not coincidental.

8. Joint Probability and Expected Number of Candidates
The 27 moduli are coprime with each other, so the probability that a random key passes all of them is the product of the individual fractions:

P_total ≈ 10⁻²⁵

The total number of keys in the range of puzzle #71 is 2⁷⁰ ≈ 1.18 × 10²¹. Therefore, the expected number of keys that pass all filters across the entire range is:

N_expected = 1.18 × 10²¹ × 10⁻²⁵ = 1.18 × 10⁻⁴

[pbies]

I've made two scripts in python with prime numbers to eventually hit all puzzle:

Generate primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys

MAX_B = 1_000_000_000
CHUNK_SIZE = 1_000_000

def worker(args):
	start_x, end_x = args
	out = []

	for x in range(start_x, end_x):
		a = (x * 6) - 1
		b = (x * 6) + 1

		if a % 5 != 0:
			out.append(f"{a}\n")

		if b % 5 != 0:
			out.append(f"{b}\n")

		if b > MAX_B:
			break

	return "".join(out)

def generate_ranges():
	max_x = (MAX_B // 6) + 2
	for start in range(2, max_x, CHUNK_SIZE):
		end = min(start + CHUNK_SIZE, max_x)
		yield (start, end)

def main():
	with Pool(cpu_count()) as pool, open("primes02.txt", "w") as o:
		total_chunks = ((MAX_B // 6) + 2 + CHUNK_SIZE - 1) // CHUNK_SIZE

		for result in tqdm(
			pool.imap_unordered(worker, generate_ranges(), chunksize=1),
			total=total_chunks
		):
			o.write(result)

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

Search with these primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys, base58, random
import itertools, math, time
from itertools import combinations

from hdwallet import HDWallet
from hdwallet.cryptocurrencies import Bitcoin as BTC
from hdwallet.hds import BIP32HD
from hdwallet.seeds import BIP39Seed

_hdwallet = HDWallet(cryptocurrency=BTC, hd=BIP32HD)

class Timer:
	def __enter__(self):
		self.start = time.perf_counter()
	def __exit__(self, type, value, traceback):
		self.end = time.perf_counter()
		print(f"This took: {self.end - self.start: .5f} seconds")

def pvk_to_wif2(key_hex):
	return base58.b58encode_check(b'\x80' + bytes.fromhex(key_hex)).decode()

targets=set()

def go(key_hex):
	_hdwallet.from_private_key(key_hex)
	t=_hdwallet.address('P2PKH')
	if t in targets:
		wif1 = pvk_to_wif2(key_hex)
		wif2 = _hdwallet.wif()
		line = f'{key_hex} {wif1} {wif2} {t}\n'
		with open('found.txt', 'a') as o:
			o.write(line)
			o.flush()

primes=set()

def gen():
	global primes
	for r in range(1, 6):
		i=itertools.product(primes, repeat=r)
		for j in i:
			k=math.prod(j)
			if k>=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140:
				continue
			yield hex(k)[2:].zfill(64)

def main():
	global primes, targets
	print('Loading targets...', flush=True)
	targets=set(open('input.txt','r').read().splitlines())
	print('Loading primes...', flush=True)
	with Timer():
		primes_src=set(open('primes02.txt','r').read().splitlines())
	print('Converting primes...', flush=True)
	with Timer():
		primes = set( int(x) for x in primes_src )

	print('Starting search...', flush=True)
	tmp=0
	for r in range(1, 6):
		tmp+=len(primes)**r
	t=tqdm(total=tmp)
	with Pool(cpu_count()) as pool:
		for res in pool.imap_unordered(go, gen()):
			t.update()

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

In input.txt file you need unhit puzzle addresses:

Code:

1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU
1JTK7s9YVYywfm5XUH7RNhHJH1LshCaRFR
12VVRNPi4SJqUTsp6FmqDqY5sGosDtysn4
1FWGcVDK3JGzCC3WtkYetULPszMaK2Jksv
1DJh2eHFYQfACPmrvpyWc8MSTYKh7w9eRF
1Bxk4CQdqL9p22JEtDfdXMsng1XacifUtE
15qF6X51huDjqTmF9BJgxXdt1xcj46Jmhb
1ARk8HWJMn8js8tQmGUJeQHjSE7KRkn2t8
15qsCm78whspNQFydGJQk5rexzxTQopnHZ
13zYrYhhJxp6Ui1VV7pqa5WDhNWM45ARAC
14MdEb4eFcT3MVG5sPFG4jGLuHJSnt1Dk2
1CMq3SvFcVEcpLMuuH8PUcNiqsK1oicG2D
1K3x5L6G57Y494fDqBfrojD28UJv4s5JcK
1PxH3K1Shdjb7gSEoTX7UPDZ6SH4qGPrvq
16AbnZjZZipwHMkYKBSfswGWKDmXHjEpSf
19QciEHbGVNY4hrhfKXmcBBCrJSBZ6TaVt
1EzVHtmbN4fs4MiNk3ppEnKKhsmXYJ4s74
1AE8NzzgKE7Yhz7BWtAcAAxiFMbPo82NB5
17Q7tuG2JwFFU9rXVj3uZqRtioH3mx2Jad
1K6xGMUbs6ZTXBnhw1pippqwK6wjBWtNpL
15ANYzzCp5BFHcCnVFzXqyibpzgPLWaD8b
18ywPwj39nGjqBrQJSzZVq2izR12MDpDr8
1CaBVPrwUxbQYYswu32w7Mj4HR4maNoJSX
1JWnE6p6UN7ZJBN7TtcbNDoRcjFtuDWoNL
1CKCVdbDJasYmhswB6HKZHEAnNaDpK7W4n
1PXv28YxmYMaB8zxrKeZBW8dt2HK7RkRPX
1AcAmB6jmtU6AiEcXkmiNE9TNVPsj9DULf
1EQJvpsmhazYCcKX5Au6AZmZKRnzarMVZu
18KsfuHuzQaBTNLASyj15hy4LuqPUo1FNB
15EJFC5ZTs9nhsdvSUeBXjLAuYq3SWaxTc
1HB1iKUqeffnVsvQsbpC6dNi1XKbyNuqao
1GvgAXVCbA8FBjXfWiAms4ytFeJcKsoyhL
1824ZJQ7nKJ9QFTRBqn7z7dHV5EGpzUpH3
18A7NA9FTsnJxWgkoFfPAFbQzuQxpRtCos
1NeGn21dUDDeqFQ63xb2SpgUuXuBLA4WT4
174SNxfqpdMGYy5YQcfLbSTK3MRNZEePoy
1MnJ6hdhvK37VLmqcdEwqC3iFxyWH2PHUV
1KNRfGWw7Q9Rmwsc6NT5zsdvEb9M2Wkj5Z
1PJZPzvGX19a7twf5HyD2VvNiPdHLzm9F6
1GuBBhf61rnvRe4K8zu8vdQB3kHzwFqSy7
1GDSuiThEV64c166LUFC9uDcVdGjqkxKyh
1Me3ASYt5JCTAK2XaC32RMeH34PdprrfDx
1CdufMQL892A69KXgv6UNBD17ywWqYpKut
1BkkGsX9ZM6iwL3zbqs7HWBV7SvosR6m8N
1AWCLZAjKbV1P7AHvaPNCKiB7ZWVDMxFiz
1G6EFyBRU86sThN3SSt3GrHu1sA7w7nzi4
1MZ2L1gFrCtkkn6DnTT2e4PFUTHw9gNwaj
1Hz3uv3nNZzBVMXLGadCucgjiCs5W9vaGz
16zRPnT8znwq42q7XeMkZUhb1bKqgRogyy
1KrU4dHE5WrW8rhWDsTRjR21r8t3dsrS3R
17uDfp5r4n441xkgLFmhNoSW1KWp6xVLD
13A3JrvXmvg5w9XGvyyR4JEJqiLz8ZySY3
16RGFo6hjq9ym6Pj7N5H7L1NR1rVPJyw2v
1UDHPdovvR985NrWSkdWQDEQ1xuRiTALq
15nf31J46iLuK1ZkTnqHo7WgN5cARFK3RA
1Ab4vzG6wEQBDNQM1B2bvUz4fqXXdFk2WT
1Fz63c775VV9fNyj25d9Xfw3YHE6sKCxbt
1QKBaU6WAeycb3DbKbLBkX7vJiaS8r42Xo
1CD91Vm97mLQvXhrnoMChhJx4TP9MaQkJo
15MnK2jXPqTMURX4xC3h4mAZxyCcaWWEDD
13N66gCzWWHEZBxhVxG18P8wyjEWF9Yoi1
1NevxKDYuDcCh1ZMMi6ftmWwGrZKC6j7Ux
19GpszRNUej5yYqxXoLnbZWKew3KdVLkXg
1M7ipcdYHey2Y5RZM34MBbpugghmjaV89P
18aNhurEAJsw6BAgtANpexk5ob1aGTwSeL
1FwZXt6EpRT7Fkndzv6K4b4DFoT4trbMrV
1CXvTzR6qv8wJ7eprzUKeWxyGcHwDYP1i2
1MUJSJYtGPVGkBCTqGspnxyHahpt5Te8jy
13Q84TNNvgcL3HJiqQPvyBb9m4hxjS3jkV
1LuUHyrQr8PKSvbcY1v1PiuGuqFjWpDumN
18192XpzzdDi2K11QVHR7td2HcPS6Qs5vg
1NgVmsCCJaKLzGyKLFJfVequnFW9ZvnMLN
1AoeP37TmHdFh8uN72fu9AqgtLrUwcv2wJ
1FTpAbQa4h8trvhQXjXnmNhqdiGBd1oraE
14JHoRAdmJg3XR4RjMDh6Wed6ft6hzbQe9
19z6waranEf8CcP8FqNgdwUe1QRxvUNKBG
14u4nA5sugaswb6SZgn5av2vuChdMnD9E5
1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv

That was my research that I deleted; I think you copied it, but oh well.


The publication of the solved keys in the file bitcoin-puzzle-solved- provided 18 keys from puzzles #65 to #130. The analysis of these keys revealed deterministic patterns that allow for the construction of extremely selective modular filters. This report details the discovery process, the validation of the filters, and their implementation in a GPU attack that can solve puzzle #71 in a matter of days with sufficient hardware.

2. Starting Data: Private Keys from Puzzles #65 to #130
The 18 known keys (in hexadecimal) are:

Puzzle   Private Key (hex)
65   1a838b13505b26867
66   2832ed74f2b5e35ee
67   730fc235c1942c1ae
68   bebb3940cd0fc1491
69   101d83275fb2bc7e0c
70   349b84b6431a6c4ef1
75   4c5ce114686a1336e07
80   ea1a5c66dcc11b5ad180
85   11720c4f018d51b8cebba8
90   2ce00bb2136a445c71e85bf
95   527a792b183c7f64a0e8b1f4
100   af55fc59c335c8ec67ed24826
105   16f14fc2054cd87ee6396b33df3
110   35c0d7234df7deb0f20cf7062444
115   60f4d11574f5deee49961d9609ac6
120   b10f22572c497a836ea187f2e1fc23
125   1c533b6bb7f0804e09960225e44877ac
130   33e7665705359f04f28b88cf897c603c9
These 18 samples are the basis of the entire analysis.

3. First Biases: Modulo 910
Calculating the residues of the 18 keys modulo 910 revealed three constraints:

No residue ends in 0, 6, or 8 (last decimal digit).

No residue is congruent with 3 (modulo 7).

No residue is congruent with 3 or 6 (modulo 13).

Combining these three conditions using the Chinese Remainder Theorem yields a set of 462 allowed residues modulo 910. The probability that 18 random keys would satisfy this is less than 0.2%. This is a deliberate rule set by the creator.

4. Systematic Sweep of Moduli
A script was developed that, for each modulus m between 2 and 2000, calculated the residues of the 18 keys and measured the reduction. It was required that all 18 keys have their residue within the observed subset. Only a few moduli passed this test. Three stood out for their extremely high reduction:

Modulus   Size   Observed Residues
467   16   [10, 12, 31, 83, 202, 213, 226, 280, 283, 291, 292, 296, 378, 391, 438, 444]
491   16   [16, 25, 30, 102, 141, 162, 196, 228, 241, 284, 375, 392, 429, 462, 473, 490]
489   17   [34, 62, 99, 126, 136, 224, 245, 256, 268, 274, 280, 327, 388, 420, 438, 457, 459]
The probability that 18 random numbers in ranges of that size would fit into such small subsets is infinitesimal (on the order of 10⁻⁸⁰). These biases are real and deliberate.

5. Additional Filters from the Euclid Family
Numbers of the form M = k × pₙ# + 1 were explored, where pₙ# is the primorial (product of the first n primes). Many moduli (mostly primes) were found that also produce very small residue sets. Below is the complete list of the 27 moduli discovered, along with the size of their residue sets:

Modulus   Size   Approximate Fraction
910   462   0.508
467   16   0.0343
491   16   0.0326
489   17   0.0348
23   10   0.435
29   13   0.448
59   13   0.220
61   14   0.230
67   15   0.224
73   15   0.205
83   16   0.193
89   16   0.180
103   17   0.165
109   13   0.119
151   17   0.113
157   15   0.0955
173   17   0.0983
181   17   0.0939
199   17   0.0854
239   17   0.0711
241   16   0.0664
421   17   0.0404
601   17   0.0283
631   17   0.0269
1471   17   0.0116
2311   18   0.00779
200560490131   18   9.0×10⁻¹¹
The residue sets were obtained directly from the 18 keys, meaning all known keys pass all these filters.

6. Nibble Filter (bits 0-15)
Analyzing the 4 least significant bits of the 18 keys, it was observed that they never take the values {2, 5, 10, 11, 13}. Extending the analysis to the following nibbles (bits 4-7, 8-11, 12-15) revealed:

Nibble 1 (bits 4-7): forbidden values {1, 3, 5, 7, 13}

Nibble 2 (bits 8-11): forbidden value {1}

Nibble 3 (bits 12-15): forbidden value {15}

These filters are independent and are applied with simple bit comparisons. The probability that a key passes all four is:

(11/16)² × (15/16)² = 27225/65536 ≈ 0.4155

Speedup factor: 1 / 0.4155 ≈ 2.41×.

7. Cross-Validation
It was verified that all 18 known keys pass all the modular and nibble filters. It was also checked that puzzles prior to #65 (1-64) do not satisfy these filters, indicating that the creator changed their generation method starting from #65. This is irrelevant for #71, which belongs to the same group.

Furthermore, an extraordinary coincidence was discovered: the hash160 of the puzzle #71 address (f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8) is also an Ethereum address with funds. The probability of a random hash160 matching an existing ETH address is less than 2⁻¹⁶⁰. This demonstrates that the creator deliberately chooses keys with special properties, reinforcing the hypothesis that the patterns are not coincidental.

8. Joint Probability and Expected Number of Candidates
The 27 moduli are coprime with each other, so the probability that a random key passes all of them is the product of the individual fractions:

P_total ≈ 10⁻²⁵

The total number of keys in the range of puzzle #71 is 2⁷⁰ ≈ 1.18 × 10²¹. Therefore, the expected number of keys that pass all filters across the entire range is:

N_expected = 1.18 × 10²¹ × 10⁻²⁵ = 1.18 × 10⁻⁴

Stop talking bs. You are lying.,

I didn't copied anything from anyone. I work on my own. Stop making false accusations.

This is first warning for you.

[brainless]

Bitcoin is decentralized
But market price indicate some people's controlling these whole Blockchain
May I saying correct ?

[fixedpaul]

Combining these three conditions using the Chinese Remainder Theorem yields a set of 462 allowed residues modulo 910. The probability that 18 random keys would satisfy this is less than 0.2%. This is a deliberate rule set by the creator.

Texas sharpshooter fallacy

[Bram24732]

Combining these three conditions using the Chinese Remainder Theorem yields a set of 462 allowed residues modulo 910. The probability that 18 random keys would satisfy this is less than 0.2%. This is a deliberate rule set by the creator.

Texas sharpshooter fallacy

Haha, FP destroying dreams with three words

[viljy]

Furthermore, an extraordinary coincidence was discovered: the hash160 of the puzzle #71 address (f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8) is also an Ethereum address with funds. The probability of a random hash160 matching an existing ETH address is less than 2⁻¹⁶⁰. This demonstrates that the creator deliberately chooses keys with special properties, reinforcing the hypothesis that the patterns are not coincidental.

The puzzle was created in 2015. The first and only transaction to this ETH address was in 2022. So the creator has a "prophecy horizon" of 7 years?
Don't you feel sorry for your time for all that you have written here?

[ars_pk]

Hello everyone! I've reduced the public key for puzzle #135 and created a database of 67 million public keys/addresses. I think I'm not the first, but no one has posted a database of public keys. This database contains two public keys/addresses in the 105-108 bit range (100000000000000000000000000:fffffffffffffffffffffffffffffff). This range is easier to brute-force.

The file xyz135rew_pub.txt can be used with keyhunt-Cuda and keyhunt in "xpoints" mode to find the public key.
https://drive.google.com/file/d/1OZQAwZjMUkfiySSr1GlQaYivY76uAUc3/view?usp=sharing
Create a bin file for the KeyHunt-Cuda program:
py pubkeys_to_xpoint.py xyz135rew_pub.txt xyz135rew_pub.bin
BinSort.exe 32 xyz135rew_pub.bin xyz135rew_pub_sort.bin
Launching KeyHunt-Cuda
KeyHunt-Cuda.exe -t 0 -r 400000 -g --gpui 0 --gpux 256,256 -m xpoints --coin BTC --range 100000000000000000000000000:fffffffffffffffffffffffffff -i xyz135rew_pub_sort.bin
Launching keyhunt
keyhunt.exe -m xpoint -R -f xyz135rew_pub.txt -n 65536 -t 32 -r 100000000000000000000000000:fffffffffffffffffffffffffff

The file xyz135_address.txt can be used to find the address.
https://drive.google.com/file/d/1HvlzxWtziYY4Ewd1GsDHplaG851KqrqC/view?usp=sharing

If you find the private key from the database, send me a message to email ciktaa@mail.ru or write me a private message on this website to find out how to contact you, and I'll recalculate it back into puzzle #135, and the funds will be split equally.

Let's find #135 together!

[JackMazzoni]

Hello everyone! I've reduced the public key for puzzle #135 and created a database of 67 million public keys/addresses. I think I'm not the first, but no one has posted a database of public keys. This database contains two public keys/addresses in the 105-108 bit range (100000000000000000000000000:fffffffffffffffffffffffffffffff). This range is easier to brute-force.

The file xyz135rew_pub.txt can be used with keyhunt-Cuda and keyhunt in "xpoints" mode to find the public key.
https://drive.google.com/file/d/1OZQAwZjMUkfiySSr1GlQaYivY76uAUc3/view?usp=sharing
Create a bin file for the KeyHunt-Cuda program:
py pubkeys_to_xpoint.py xyz135rew_pub.txt xyz135rew_pub.bin
BinSort.exe 32 xyz135rew_pub.bin xyz135rew_pub_sort.bin
Launching KeyHunt-Cuda
KeyHunt-Cuda.exe -t 0 -r 400000 -g --gpui 0 --gpux 256,256 -m xpoints --coin BTC --range 100000000000000000000000000:fffffffffffffffffffffffffff -i xyz135rew_pub_sort.bin
Launching keyhunt
keyhunt.exe -m xpoint -R -f xyz135rew_pub.txt -n 65536 -t 32 -r 100000000000000000000000000:fffffffffffffffffffffffffff

The file xyz135_address.txt can be used to find the address.
https://drive.google.com/file/d/1HvlzxWtziYY4Ewd1GsDHplaG851KqrqC/view?usp=sharing

If you find the private key from the database, send me a message to email ciktaa@mail.ru or write me a private message on this website to find out how to contact you, and I'll recalculate it back into puzzle #135, and the funds will be split equally.

Let's find #135 together!

Keyhunt cannot deal with 67 million keys. It would make it very slow.

[ars_pk]

Keyhunt cannot deal with 67 million keys. It would make it very slow.

KeyHunt-Cuda v1.07

COMP MODE    : COMPRESSED
COIN TYPE    : BITCOIN
SEARCH MODE  : Multi X Points
DEVICE       : GPU
CPU THREAD   : 0
GPU IDS      : 0
GPU GRIDSIZE : 256x256
SSE          : NO
RKEY         : 400000 Mkeys
MAX FOUND    : 65536
BTC XPOINTS  : xyz135_105108_sort.bin
OUTPUT FILE  : Found.txt

Loading      : 100 %Loaded       : 67,143,110 Bitcoin xpoints

Bloom at 000002777E06D590
  Version    : 2.1
  Entries    : 134286220
  Error      : 0.0000010000
  Bits       : 3861423773
  Bits/Elem  : 28.755175
  Bytes      : 482677972 (460 MB)
  Hash funcs : 20

Start Time   : Sun Feb 22 16:20:55 2026
Base Key     : Randomly changes on every 400000 Mkeys
Global start : 100000000000000000000000000 (105 bit)
Global end   : FFFFFFFFFFFFFFFFFFFFFFFFFFF (108 bit)
Global range : EFFFFFFFFFFFFFFFFFFFFFFFFFF (108 bit)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 Laptop GPU (76x0 cores) Grid(256x256)

[00:01:43] [CPU+GPU: 1835.49 Mk/s] [GPU: 1835.49 Mk/s] [C: 0.000000 %] [R: 0] [T: 189,246,996,480 (38 bit)] [F: 0]

The KeyHunt-Cuda program was also launched on the following video cards:
NVIDIA GeForce RTX 3050 Laptop GPU - 600 Mk/s
NVIDIA GeForce RTX 3060 Ti - 1400 Mk/s

I only have one 4090 video card on my laptop, but I know there are guys here who have a rig made of 5090.