Bitcoin puzzle transaction ~32 BTC prize to who solves it

[lordfrs]

Digaran. When phones with 64-bit CPUs appear, I will port the program code for the phone, especially for you

There is a phone with a 64-bit processor. Don't you know?

Asus ZenFone 2

Intel Atom Z3580
4x 2.33 GHz Atom Z3580    
64-bit

went on sale 8 years ago

[alek76]

There is a phone with a 64-bit processor. Don't you know?

I didn’t know..., that means I’m behind They are not common among all users, we need to wait another 8 years, then 66 bits will be solved and we’ll move on to 67 bits. You can port the code, I think it won’t take much time.
I don't have such a phone to test the program.

[alek76]

Script for check / generating address + wif and hex key. P2PKH Compressed / UnCompressed address.
If you need an address without an online service.
Python 2.7 code:

Code:

#! /usr/bin/env python

import random
from ecdsa.ecdsa import int_to_string
from ecdsa.ecdsa import string_to_int
from binascii import hexlify
import hashlib


class CurveFp( object ):
  def __init__( self, p, a, b ):
    self.__p = p
    self.__a = a
    self.__b = b

  def p( self ):
    return self.__p

  def a( self ):
    return self.__a

  def b( self ):
    return self.__b

  def contains_point( self, x, y ):
    return ( y * y - ( x * x * x + self.__a * x + self.__b ) ) % self.__p == 0

class Point( object ):
  def __init__( self, curve, x, y, order = None ):
    self.__curve = curve
    self.__x = x
    self.__y = y
    self.__order = order
    if self.__curve: assert self.__curve.contains_point( x, y )
    if order: assert self * order == INFINITY
 
  def __add__( self, other ):
    if other == INFINITY: return self
    if self == INFINITY: return other
    assert self.__curve == other.__curve
    if self.__x == other.__x:
      if ( self.__y + other.__y ) % self.__curve.p() == 0:
        return INFINITY
      else:
        return self.double()

    p = self.__curve.p()
    l = ( ( other.__y - self.__y ) * \
          inverse_mod( other.__x - self.__x, p ) ) % p
    x3 = ( l * l - self.__x - other.__x ) % p
    y3 = ( l * ( self.__x - x3 ) - self.__y ) % p
    return Point( self.__curve, x3, y3 )

  def __mul__( self, other ):
    def leftmost_bit( x ):
      assert x > 0
      result = 1L
      while result <= x: result = 2 * result
      return result / 2

    e = other
    if self.__order: e = e % self.__order
    if e == 0: return INFINITY
    if self == INFINITY: return INFINITY
    assert e > 0
    e3 = 3 * e
    negative_self = Point( self.__curve, self.__x, -self.__y, self.__order )
    i = leftmost_bit( e3 ) / 2
    result = self
    while i > 1:
      result = result.double()
      if ( e3 & i ) != 0 and ( e & i ) == 0: result = result + self
      if ( e3 & i ) == 0 and ( e & i ) != 0: result = result + negative_self
      i = i / 2
    return result

  def __rmul__( self, other ):
    return self * other

  def __str__( self ):
    if self == INFINITY: return "infinity"
    return "(%d,%d)" % ( self.__x, self.__y )

  def double( self ):
    if self == INFINITY:
      return INFINITY

    p = self.__curve.p()
    a = self.__curve.a()
    l = ( ( 3 * self.__x * self.__x + a ) * \
          inverse_mod( 2 * self.__y, p ) ) % p
    x3 = ( l * l - 2 * self.__x ) % p
    y3 = ( l * ( self.__x - x3 ) - self.__y ) % p
    return Point( self.__curve, x3, y3 )

  def x( self ):
    return self.__x

  def y( self ):
    return self.__y

  def curve( self ):
    return self.__curve
  
  def order( self ):
    return self.__order
    
INFINITY = Point( None, None, None )

def inverse_mod( a, m ):
  if a < 0 or m <= a: a = a % m
  c, d = a, m
  uc, vc, ud, vd = 1, 0, 0, 1
  while c != 0:
    q, c, d = divmod( d, c ) + ( c, )
    uc, vc, ud, vd = ud - q*uc, vd - q*vc, uc, vc
  assert d == 1
  if ud > 0: return ud
  else: return ud + m

# secp256k1
_p  = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2FL
_r  = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141L
_b  = 0x0000000000000000000000000000000000000000000000000000000000000007L
_a  = 0x0000000000000000000000000000000000000000000000000000000000000000L
_Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798L
_Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8L

class Public_key( object ):
  def __init__( self, generator, point ):
    self.curve = generator.curve()
    self.generator = generator
    self.point = point
    n = generator.order()
    if not n:
      raise RuntimeError, "Generator point must have order."
    if not n * point == INFINITY:
      raise RuntimeError, "Generator point order is bad."
    if point.x() < 0 or n <= point.x() or point.y() < 0 or n <= point.y():
      raise RuntimeError, "Generator point has x or y out of range."

curve_256 = CurveFp( _p, _a, _b )
generator_256 = Point( curve_256, _Gx, _Gy, _r )
g = generator_256

b58_digits = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

### generate privkey
randrange = random.SystemRandom().randrange
n = g.order()
#n = 115792089237316195423570985008687907852837564279074904382605163141518161494337

ripehash = hashlib.new('ripemd160')

def b58encode(b):
    
n = int('0x0' + hexlify(b).decode('utf8'), 16)
res = []
while n > 0:
n, r = divmod (n, 58)
res.append(b58_digits[r])
res = ''.join(res[::-1])
import sys
czero = b'\x00'
if sys.version > '3':
czero = 0
pad = 0
for c in b:
if c == czero: pad += 1
else: break
return b58_digits[0] * pad + res

###

#Compress_fl = 0 # UNCompressed
Compress_fl = 1 # Compressed

### Start generate secret
password = "123" # SET PASSWORD -----------------------!!!!!!!!!!!!!!!!!!!!!----------------------- SET PASSWORD
#password = raw_input('Your string here:')
sha1 = hashlib.sha256(password).digest()
temp1 = string_to_int(sha1)
secret_bw = temp1 # brainwallet
### End generate secret

#secret = secret_bw # brainwallet

secret = randrange( 1, 2**256 )

### SET SECRET KEY ###
### SET SECRET KEY ###
### SET SECRET KEY ###
### SET SECRET KEY ###
### SET SECRET KEY ###

#secret = 0xf13b87e9L # PointX len 62

#secret = 0xF7051F27B09112D4

### SET SECRET KEY ###
print '====================================================================================='
print 'Secret Key: '
print hex(secret)
print '====================================================================================='

### generate pubkey
myp = g * secret
### generate address

print "Points: "

px_str = hex(myp.x())[2:-1]
py_str = hex(myp.y())[2:-1]

while len(px_str) < 64:
    #print 'px_str: ', len(px_str)
    px_str = '0' + px_str

while len(py_str) < 64:
    #print 'py_str: ', len(py_str)
    py_str = '0' + py_str

print px_str
print py_str

print '====================================================================================='

# if Compressed address
if myp.y() % 2 == 0:
y_parity = '\x02'
pk_y_parity = '02'
#print "02" + px_str
else:
y_parity = '\x03'
pk_y_parity = '03'
#print "03" + px_str

# Public Key
if Compress_fl:
    pk = pk_y_parity + px_str
else:
    pk = '04' + px_str + py_str
print 'Public Key: '
print pk
print '====================================================================================='

# !!! NORMALIZE Length !!!
print 'NORMALIZE Length PointX and PointY'
# Point X
px_string = int_to_string(myp.x())

if len(px_string) < 32:
    print 'NORMALIZE Length PointX: ', len(px_string)

while len(px_string) < 32:
    px_string = '\x00' + px_string

print 'Check len PointX: ', len(px_string)

# Point Y
py_string = int_to_string(myp.y())

if len(py_string) < 32:
    print 'NORMALIZE Length PointY: ', len(py_string)

while len(py_string) < 32:
    py_string = '\x00' + py_string

print 'Check len PointY: ', len(py_string)

print '====================================================================================='

if Compress_fl:
    step1_mod = y_parity + px_string  # Compressed
else:
    step1_mod = '\x04' + px_string + py_string # UNCompressed

# End

step2 = hashlib.sha256(step1_mod).digest()

print "Pubkey sha256: "
istep2 = string_to_int(step2)
Psha256 = hex(istep2)[2:-1]
print Psha256
print '====================================================================================='

ripehash.update(step2)
step3 = ripehash.digest()
address160 = hex(string_to_int(step3))[2:-1]
print "Address hash160: "
print address160
step4 = '\x00' + ripehash.digest()
step5 = hashlib.sha256(step4).digest()
step6 = hashlib.sha256(step5).digest()
chksum = step6[:4]
addr = step4 + chksum
address = b58encode(addr)
#print address
### Convert private key to wallet import format
wif1 = int_to_string(secret)
i = 0;
while  i < (64 - len(hex(secret)[2:-1])) / 2:
wif1 = '\x00' + wif1
i = i + 1

#wif2 = '\x80' + wif1
# Compressed privkey
if Compress_fl:
    wif2 = '\x80' + wif1 + '\x01' # Compressed privkey
    addr_mode_str = 'Compressed'
else:
    wif2 = '\x80' + wif1 #        # UNCompressed privkey
    addr_mode_str = 'UnCompressed'

wif3 = hashlib.sha256(wif2).digest()
wif4 = hashlib.sha256(wif3).digest()
wif5 = wif4[:4]
wif6 = wif2 + wif5
wif = b58encode(wif6)
#print wif
### Save address and private key in priv.txt
hexsecret = hex(secret)

file_name = 'p_r_v.txt'

f = open(file_name, 'a')
f.write('\n'.join([addr_mode_str + ' Address: ' + address, 'Address hash160:    ' + address160, 'Secret wif: ' + wif, 'Secret hex: ' + hexsecret, 'PK: ' + pk, \
                   'Px: ' + px_str, 'Py: ' + py_str + '\n\n' ]))
f.close()
print '====================================================================================='
print 'Save ' + addr_mode_str + ' Address: ' + address
print 'Save Address hash160:    ' + address160
print 'Save WIF PrivKey: ' + wif
print 'Save Hex PrivKey: ' + hexsecret
print 'Save Public Key:  ' + pk
print '====================================================================================='
raw_input("... Press Enter")
raise SystemExit

Result output + write in file p_r_v.txt

Code:

Compressed Address: 18cdpW3P6imyDz6w622nYAGXvSznCM5om9
Address hash160:    53862c90c2a994c7a874bb091f9b8e51fcdaa06c
Secret wif: L3zSyzX1ky3QbEcvC6fHE9eDyuznswoDCsvGvCeiTuH2fkmN3L2G
Secret hex: 0xca0a0ca7838e9dfee4aaa0cfbee29b69a8f67dae595d993a71fdaab4a01287e2L
PK: 029c5b2d21be2b2bbeca4ac1cf1233c591e1127a355cdd564c880e88f98985efe7
Px: 9c5b2d21be2b2bbeca4ac1cf1233c591e1127a355cdd564c880e88f98985efe7
Py: 3c36a84972cbe787b26822596014625fa801981f38c56597d0c03f38f3ee93bc

Compressed Address: 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN
Address hash160:    3ee4133d991f52fdf6a25c9834e0745ac74248a4
Secret wif: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZ6FxoaD5r1kYegmtbaT
Secret hex: 0xf7051f27b09112d4L
PK: 03100611c54dfef604163b8358f7b7fac13ce478e02cb224ae16d45526b25d9d4d
Px: 100611c54dfef604163b8358f7b7fac13ce478e02cb224ae16d45526b25d9d4d
Py: 5127c2d0b1c4a4d5b4996bbdf37633b86901d0303b61e2f6f0772282ae08ff95

Hello all, is there any python code for public key addition and checking it's hash ?

Yes, look at the iceland2k14/secp256k1 script and create your script to fit within his script.

Also, what do you mean by "checking it's hash"? H160?

Yes , hash160 . I saw his code , I am just good at math but very bad at programming so I couldn't understand the code honestly

Simplest

Code:

import sys, secrets, secp256k1 as ice
while True:
    dec = secrets.SystemRandom().randrange(36893488147419103231, 73786976294838206463)
    h160 = ice.privatekey_to_h160(1, True, dec).hex()
    message = "\r{}".format(h160);messages = []
    messages.append(message);output = "\033[01;33m" + ''.join(messages) + "\r"
    sys.stdout.write(output);sys.stdout.flush()
    if h160 == "20d45a6a762535700ce9e0b216e31994335db8a5":
        HEX = "%064x" % dec;wifc = ice.btc_pvk_to_wif(HEX)
        with open("KEYFOUNDKEYFOUND.txt", "a") as f:
          f.write(f'Private key (wif) Compressed : {wifc}\n')
        break

Im found ERROR. The code search address type P2SH. Still looking for a P2SH address?
For search P2PKH address replace str:

Code:

h160 = ice.privatekey_to_h160(1, True, dec).hex()

to str:

Code:

h160 = ice.privatekey_to_h160(0, True, dec).hex()

Code:

def _privatekey_to_h160(addr_type, iscompressed, pvk_int):
    # type = 0 [p2pkh],  1 [p2sh],  2 [bech32]

I don’t want to upset anyone, but many people make similar mistakes when they are in a hurry. To be honest, I only noticed the error myself.
The main thing is that 1000 kW hours of energy were not wasted. Please

[nomachine]

many people make similar mistakes when they are in a hurry. To be honest, I only noticed the error myself.
The main thing is that 1000 kW hours of energy were not wasted. Please

Thank you very much - I changed it in the original post. This is proof that I'm not an AI...I admit when I'm wrong.

anyway,  I just solved Puzzle 60 in 16 seconds

• STARTED: Sat Dec 23 11:52:59 2023
• [Puzzle]: 60
• [Lower range limit]: 576460752303423488
• [Upper range limit]: 1152921504606846975
• [Using  12 CPU cores for parallel search]:
• [Core]: 11, [Random seed]: b'a\xc6?\xb5\xd8$\xc9*\xe1'
• [Core]: 12, [Random seed]: b'\x17\xd7%&\xaa&\xbfL\x94'
• [Core]: 02, [Random seed]: b'\xca[s\xfex3\x9d\xe3I'
• [Core]: 04, [Random seed]: b'\xf9\x84Z\x16\xeb\xd4\xef%\x83'
• [Core]: 03, [Random seed]: b'\xab\xba\xaa\x90\xd0\xd5H\xa0\xeb'
• [Core]: 05, [Random seed]: b'\xd6\x1aA{]\xb3s\xc8\x0f'
• [Core]: 06, [Random seed]: b'<\x04t\xacV0LB\xc5'
• [Core]: 08, [Random seed]: b'\xde\x1d\x1f\xef\xab\x8aL\xbb\xc6'
• [Core]: 10, [Random seed]: b'\x03\xadO\x97\xd8\xdf \xf4\x08'
• [Core]: 11, [Random seed]: b'*E\x99\xf3f\xe9\xf6\xb48'
• [Core]: 12, [Random seed]: b'\xa0\xb7\xf4r\xc2*\x1b"\xc4'
• [Core]: 01, [Random seed]: b'ahP+B\xb6rJ\xf6'
• PUZZLE SOLVED: Sat Dec 23 11:53:15 2023, total time: 16.213455915 sec
• WIF:  KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYkzijLsc5qE43yZ5eLV
• PUZZLE SOLVED! Stopping the loop.

Code:

import sys, os, time, hashlib, gmpy2, random, multiprocessing
from multiprocessing import Pool, cpu_count
from gmpy2 import mpz
import secp256k1 as ice

if os.name=='nt':os.system('cls')
else:os.system('clear')
t = time.ctime()
sys.stdout.write(f"\033[?25l")
sys.stdout.write(f"\033[01;33m[+] STARTED: {t}\n")
sys.stdout.flush()

MODULO = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
ORDER = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
GX = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
GY = gmpy2.mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

class Point:
    def __init__(self, x=0, y=0):
        self.x = gmpy2.mpz(x)
        self.y = gmpy2.mpz(y)

PG = Point(GX, GY)
ZERO_POINT = Point(0, 0)

def multiply_by_2(P, p=MODULO):
    x_squared = P.x**2 % p
    c = (3 * x_squared * gmpy2.invert((P.y + P.y) % p, p)) % p

    R = Point()
    R.x = (c**2 - 2 * P.x) % p
    R.y = (c * (P.x - R.x) - P.y) % p

    return R

def add_points(P, Q, p=MODULO):
    dx = Q.x - P.x
    dx_inv = gmpy2.invert(dx, p)
    dy_dx_inv = (Q.y - P.y) * dx_inv

    R = Point()
    R.x = (dy_dx_inv**2 - P.x - Q.x) % p
    R.y = (dy_dx_inv * (P.x - R.x) - P.y) % p

    return R

def mod_pow(base, exponent, modulus):
    result = 1
    base = base % modulus

    while exponent > 0:
        if exponent % 2 == 1:
            result = (result * base) % modulus
        exponent = exponent // 2
        base = (base * base) % modulus

    return result

def x_to_y(X, y_parity, p=MODULO):
    X_cubed = (X**3) % p
    X = (X_cubed + 7) % p

    Y = (p + 1) // 4
    tmp = mod_pow(X, Y, p)

    if gmpy2.is_odd(tmp) != y_parity:
        tmp = -tmp % p

    return tmp

def compute_point_table():
    points = [PG]
    for k in range(255):
        points.append(multiply_by_2(points[k]))
    return points

POINTS_TABLE = compute_point_table()
STOP_EVENT = multiprocessing.Event()

def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    check = gmpy2.f_mod(P.x, DP_rarity)
    if check == 0:
        A.append(mpz(P.x))
        Ak.append(mpz(Pindex))
        message = "\r[+] [Pindex]: {}".format(Pindex)
        messages = []
        messages.append(message)
        output = ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        return comparator(A, Ak, B, Bk)
    else:
        return False

def comparator(A, Ak, B, Bk):
    global STOP_EVENT
    result = set(A).intersection(set(B))

    if result:
        t = time.ctime()
        total_time = time.time() - starttime
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        HEX = "%064x" % abs(Ak[sol_kt] - Bk[sol_kw])
        dec = int(HEX, 16)
        wifc = ice.btc_pvk_to_wif(HEX)
        wifu = ice.btc_pvk_to_wif(HEX, False)
        caddr = ice.privatekey_to_address(0, True, dec)  
        uaddr = ice.privatekey_to_address(0, False, dec)
        pid = os.getpid()  # Get the process ID
        core_number = pid % cpu_count()  # Calculate the CPU core number
        sys.stdout.write("\033[?25h")
        sys.stdout.flush()
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.9f} sec, Core: {core_number+1:02} \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {wifc} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nSOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.9f} sec")
            file.write("\nPrivate Key (decimal): " + str(dec))
            file.write("\nPrivate Key (hex): " + HEX)
            file.write("\nPrivate key (wif) Compressed : " + wifc)
            file.write("\nPrivate key (wif) Uncompressed: " + wifu)
            file.write("\nBitcoin address Compressed: " + caddr)
            file.write("\nBitcoin address Uncompressed: " + uaddr)
            file.write(
                "\n-------------------------------------------------------------------------------------------------------------------------------------------\n"
            )

        STOP_EVENT.set()  # Set the stop event to signal all processes

ECMULTIPLY_MEMO = {}

def ecmultiply(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        if k in ECMULTIPLY_MEMO:
            return ECMULTIPLY_MEMO[k]
        else:
            result = ecmultiply(k // 2, multiply_by_2(P, p), p)
            ECMULTIPLY_MEMO[k] = result
            return result
    else:
        return add_points(P, ecmultiply((k - 1) // 2, multiply_by_2(P, p), p))

def mulk(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, multiply_by_2(P, p), p)
    else:
        return add_points(P, mulk((k - 1) // 2, multiply_by_2(P, p), p))

def generate_powers_of_two(hop_modulo):
    return [mpz(1 << pw) for pw in range(hop_modulo)]

# Configuration for the Puzzle
puzzle = 60
compressed_public_key = "0348e843dc5b1bd246e6309b4924b81543d02b16c8083df973a89ce2c7eb89a10d"
lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2 ** puzzle) - 1
power = (puzzle // cpu_count()) + 1
Nt = Nw = (2 ** power // puzzle) * puzzle + cpu_count()
DP_rarity = (puzzle * puzzle)
hop_modulo = (puzzle // 2) + cpu_count()

powers_of_two = generate_powers_of_two(hop_modulo)
T, t, dt = [], [], []
W, w, dw = [], [], []

if len(compressed_public_key) == 66:
    X = mpz(compressed_public_key[2:66], 16)
    Y = x_to_y(X, mpz(compressed_public_key[:2]) - 2)
else:
    print("[error] pubkey len(66/130) invalid!")

print(f"[+] [Puzzle]: {puzzle}")
print(f"[+] [Lower range limit]: {lower_range_limit}")
print(f"[+] [Upper range limit]: {upper_range_limit}")

W0 = Point(X, Y)
starttime = oldtime = time.time()
Hops = 0

def search_worker(
    Nt, Nw, puzzle, power, starttime, lower_range_limit, upper_range_limit
):
    global STOP_EVENT
    pid = os.getpid()
    core_number = pid % cpu_count()
    #Random Seed Config
    constant_prefix = b''  # b'' is back to no constant
    prefix_length = len(constant_prefix)
    length = 9
    ending_length = length - prefix_length
    ending_bytes = os.urandom(ending_length)
    random_bytes = constant_prefix + ending_bytes
    print(f"[+] [Core]: {core_number+1:02}, [Random seed]: {random_bytes}")
    random.seed(random_bytes)
    t = [mpz(random.randint(lower_range_limit, upper_range_limit)) for _ in range(Nt)]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
  
    w = [mpz(random.randint(lower_range_limit, upper_range_limit)) for _ in range(Nw)]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0
    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                break
            t[k] = mpz(t[k]) + dt[k]  # Use mpz here
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                break
            w[k] = mpz(w[k]) + dw[k]  # Use mpz here
            W[k] = add_points(POINTS_TABLE[pw], W[k])

        if STOP_EVENT.is_set():
            break

if __name__ == "__main__":
    process_count = cpu_count()
    print(f"[+] [Using  {process_count} CPU cores for parallel search]:")

    # Create a pool of worker processes
    pool = Pool(process_count)
    results = pool.starmap(
        search_worker,
        [
            (
                Nt,
                Nw,
                puzzle,
                power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join()

Loop script in bash (seed hunter)

Code:

#!/bin/bash

while true; do
    timeout 30 python3 puzzle.py
    sleep 2
    if [ -n "$(find . -maxdepth 1 -type f -name 'KEYFOUNDKEYFOUND.txt' -print -quit)" ]; then
        echo "[+] PUZZLE SOLVED! Stopping the loop."
        break
    fi
done

set the timeout as you wish.

[mabdlmonem]

many people make similar mistakes when they are in a hurry. To be honest, I only noticed the error myself.
The main thing is that 1000 kW hours of energy were not wasted. Please

Thank you very much - I changed it in the original post. This is proof that I'm not an AI...I admit when I'm wrong.

anyway,  I just solved Puzzle 60 in 16 seconds

• STARTED: Sat Dec 23 11:52:59 2023
• [Puzzle]: 60
• [Lower range limit]: 576460752303423488
• [Upper range limit]: 1152921504606846975
• [Using  12 CPU cores for parallel search]:
• [Core]: 11, [Random seed]: b'a\xc6?\xb5\xd8$\xc9*\xe1'
• [Core]: 12, [Random seed]: b'\x17\xd7%&\xaa&\xbfL\x94'
• [Core]: 02, [Random seed]: b'\xca[s\xfex3\x9d\xe3I'
• [Core]: 04, [Random seed]: b'\xf9\x84Z\x16\xeb\xd4\xef%\x83'
• [Core]: 03, [Random seed]: b'\xab\xba\xaa\x90\xd0\xd5H\xa0\xeb'
• [Core]: 05, [Random seed]: b'\xd6\x1aA{]\xb3s\xc8\x0f'
• [Core]: 06, [Random seed]: b'<\x04t\xacV0LB\xc5'
• [Core]: 08, [Random seed]: b'\xde\x1d\x1f\xef\xab\x8aL\xbb\xc6'
• [Core]: 10, [Random seed]: b'\x03\xadO\x97\xd8\xdf \xf4\x08'
• [Core]: 11, [Random seed]: b'*E\x99\xf3f\xe9\xf6\xb48'
• [Core]: 12, [Random seed]: b'\xa0\xb7\xf4r\xc2*\x1b"\xc4'
• [Core]: 01, [Random seed]: b'ahP+B\xb6rJ\xf6'
• PUZZLE SOLVED: Sat Dec 23 11:53:15 2023, total time: 16.213455915 sec
• WIF:  KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYkzijLsc5qE43yZ5eLV
• PUZZLE SOLVED! Stopping the loop.

Code:

import sys, os, time, hashlib, gmpy2, random, multiprocessing
from multiprocessing import Pool, cpu_count
from gmpy2 import mpz
import secp256k1 as ice

if os.name=='nt':os.system('cls')
else:os.system('clear')
t = time.ctime()
sys.stdout.write(f"\033[?25l")
sys.stdout.write(f"\033[01;33m[+] STARTED: {t}\n")
sys.stdout.flush()

MODULO = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
ORDER = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
GX = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
GY = gmpy2.mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

class Point:
    def __init__(self, x=0, y=0):
        self.x = gmpy2.mpz(x)
        self.y = gmpy2.mpz(y)

PG = Point(GX, GY)
ZERO_POINT = Point(0, 0)

def multiply_by_2(P, p=MODULO):
    x_squared = P.x**2 % p
    c = (3 * x_squared * gmpy2.invert((P.y + P.y) % p, p)) % p

    R = Point()
    R.x = (c**2 - 2 * P.x) % p
    R.y = (c * (P.x - R.x) - P.y) % p

    return R

def add_points(P, Q, p=MODULO):
    dx = Q.x - P.x
    dx_inv = gmpy2.invert(dx, p)
    dy_dx_inv = (Q.y - P.y) * dx_inv

    R = Point()
    R.x = (dy_dx_inv**2 - P.x - Q.x) % p
    R.y = (dy_dx_inv * (P.x - R.x) - P.y) % p

    return R

def mod_pow(base, exponent, modulus):
    result = 1
    base = base % modulus

    while exponent > 0:
        if exponent % 2 == 1:
            result = (result * base) % modulus
        exponent = exponent // 2
        base = (base * base) % modulus

    return result

def x_to_y(X, y_parity, p=MODULO):
    X_cubed = (X**3) % p
    X = (X_cubed + 7) % p

    Y = (p + 1) // 4
    tmp = mod_pow(X, Y, p)

    if gmpy2.is_odd(tmp) != y_parity:
        tmp = -tmp % p

    return tmp

def compute_point_table():
    points = [PG]
    for k in range(255):
        points.append(multiply_by_2(points[k]))
    return points

POINTS_TABLE = compute_point_table()
STOP_EVENT = multiprocessing.Event()

def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    check = gmpy2.f_mod(P.x, DP_rarity)
    if check == 0:
        A.append(mpz(P.x))
        Ak.append(mpz(Pindex))
        message = "\r[+] [Pindex]: {}".format(Pindex)
        messages = []
        messages.append(message)
        output = ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        return comparator(A, Ak, B, Bk)
    else:
        return False

def comparator(A, Ak, B, Bk):
    global STOP_EVENT
    result = set(A).intersection(set(B))

    if result:
        t = time.ctime()
        total_time = time.time() - starttime
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        HEX = "%064x" % abs(Ak[sol_kt] - Bk[sol_kw])
        dec = int(HEX, 16)
        wifc = ice.btc_pvk_to_wif(HEX)
        wifu = ice.btc_pvk_to_wif(HEX, False)
        caddr = ice.privatekey_to_address(0, True, dec)  
        uaddr = ice.privatekey_to_address(0, False, dec)
        pid = os.getpid()  # Get the process ID
        core_number = pid % cpu_count()  # Calculate the CPU core number
        sys.stdout.write("\033[?25h")
        sys.stdout.flush()
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.9f} sec, Core: {core_number+1:02} \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {wifc} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nSOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.9f} sec")
            file.write("\nPrivate Key (decimal): " + str(dec))
            file.write("\nPrivate Key (hex): " + HEX)
            file.write("\nPrivate key (wif) Compressed : " + wifc)
            file.write("\nPrivate key (wif) Uncompressed: " + wifu)
            file.write("\nBitcoin address Compressed: " + caddr)
            file.write("\nBitcoin address Uncompressed: " + uaddr)
            file.write(
                "\n-------------------------------------------------------------------------------------------------------------------------------------------\n"
            )

        STOP_EVENT.set()  # Set the stop event to signal all processes

ECMULTIPLY_MEMO = {}

def ecmultiply(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        if k in ECMULTIPLY_MEMO:
            return ECMULTIPLY_MEMO[k]
        else:
            result = ecmultiply(k // 2, multiply_by_2(P, p), p)
            ECMULTIPLY_MEMO[k] = result
            return result
    else:
        return add_points(P, ecmultiply((k - 1) // 2, multiply_by_2(P, p), p))

def mulk(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, multiply_by_2(P, p), p)
    else:
        return add_points(P, mulk((k - 1) // 2, multiply_by_2(P, p), p))

def generate_powers_of_two(hop_modulo):
    return [mpz(1 << pw) for pw in range(hop_modulo)]

# Configuration for the Puzzle
puzzle = 60
compressed_public_key = "0348e843dc5b1bd246e6309b4924b81543d02b16c8083df973a89ce2c7eb89a10d"
lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2 ** puzzle) - 1
power = (puzzle // cpu_count()) + 1
Nt = Nw = (2 ** power // puzzle) * puzzle + cpu_count()
DP_rarity = (puzzle * puzzle)
hop_modulo = (puzzle // 2) + cpu_count()

powers_of_two = generate_powers_of_two(hop_modulo)
T, t, dt = [], [], []
W, w, dw = [], [], []

if len(compressed_public_key) == 66:
    X = mpz(compressed_public_key[2:66], 16)
    Y = x_to_y(X, mpz(compressed_public_key[:2]) - 2)
else:
    print("[error] pubkey len(66/130) invalid!")

print(f"[+] [Puzzle]: {puzzle}")
print(f"[+] [Lower range limit]: {lower_range_limit}")
print(f"[+] [Upper range limit]: {upper_range_limit}")

W0 = Point(X, Y)
starttime = oldtime = time.time()
Hops = 0

def search_worker(
    Nt, Nw, puzzle, power, starttime, lower_range_limit, upper_range_limit
):
    global STOP_EVENT
    pid = os.getpid()
    core_number = pid % cpu_count()
    #Random Seed Config
    constant_prefix = b''  # b'' is back to no constant
    prefix_length = len(constant_prefix)
    length = 9
    ending_length = length - prefix_length
    ending_bytes = os.urandom(ending_length)
    random_bytes = constant_prefix + ending_bytes
    print(f"[+] [Core]: {core_number+1:02}, [Random seed]: {random_bytes}")
    random.seed(random_bytes)
    t = [mpz(random.randint(lower_range_limit, upper_range_limit)) for _ in range(Nt)]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
  
    w = [mpz(random.randint(lower_range_limit, upper_range_limit)) for _ in range(Nw)]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0
    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                break
            t[k] = mpz(t[k]) + dt[k]  # Use mpz here
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                break
            w[k] = mpz(w[k]) + dw[k]  # Use mpz here
            W[k] = add_points(POINTS_TABLE[pw], W[k])

        if STOP_EVENT.is_set():
            break

if __name__ == "__main__":
    process_count = cpu_count()
    print(f"[+] [Using  {process_count} CPU cores for parallel search]:")

    # Create a pool of worker processes
    pool = Pool(process_count)
    results = pool.starmap(
        search_worker,
        [
            (
                Nt,
                Nw,
                puzzle,
                power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join()

Loop script in bash (seed hunter)

Code:

#!/bin/bash

while true; do
    timeout 30 python3 puzzle.py
    sleep 2
    if [ -n "$(find . -maxdepth 1 -type f -name 'KEYFOUNDKEYFOUND.txt' -print -quit)" ]; then
        echo "[+] PUZZLE SOLVED! Stopping the loop."
        break
    fi
done

set the timeout as you wish.

why you can not solve 130 then with this code ?

[AlanJohnson]

why you can not solve 130 then with this code ?

Cause 130 isn't  60 i guess...

[mabdlmonem]

why you can not solve 130 then with this code ?

Cause 130 isn't  60 i guess...

• STARTED: Sat Dec 23 14:21:34 2023
• [Puzzle]: 60
• [Lower range limit]: 576460752303423488
• [Upper range limit]: 1152921504606846975
• [Using  32 CPU cores for parallel search]:
• [Core]: 17, [Random seed]: b'\x9aK\xff\x01\x11$o\xc9B'
• [Core]: 18, [Random seed]: b'\x8c5\xef\xdevy\xdf \x95'
• [Core]: 19, [Random seed]: b'\xe3:\xf7\r\x9e\xbc5\xf31'
• [Core]: 20, [Random seed]: b'i`)7\xe3]\xf3\xe60'
• [Core]: 21, [Random seed]: b'I\xc2\xa8\x14,\x03\x84\xc6\x1b'
• [Core]: 22, [Random seed]: b'\xf8\xa3r\x12!\xdf\x19$\x1c'
• [Core]: 23, [Random seed]: b'H\xff\x8a\xd4\xe5lt{\x10'
• [Core]: 24, [Random seed]: b'\xe7\x1f\x81\x86x\xff,c\x1d'
• [Core]: 25, [Random seed]: b'\xad\xeb\x95\xceG\x86\xbbkP'
• [Core]: 26, [Random seed]: b'Y\x9e&j\xaa=]\xad\t'
• [Core]: 27, [Random seed]: b'\x02\xfe\x1b\x81\x05\x9fRWz'
• [Core]: 28, [Random seed]: b'\xb8R!WY\xb8\xc3\x8c%'
• [Core]: 29, [Random seed]: b'\x1a\x15<<)Z\x1f\xfe\xfe'
• [Core]: 30, [Random seed]: b'sJB\xc6\xeed\xb3\xe6('
• [Core]: 31, [Random seed]: b'*Y\x1a\x84@L4\xe0\xdc'
• [Core]: 32, [Random seed]: b'\x9f\xaf\xabC\x0eQ\x95"\xa8'
• [Core]: 01, [Random seed]: b'\x0fY\x98\x02\x80\x06\xb4\xb0\xfd'
• [Core]: 02, [Random seed]: b'\x077\xd5\xc5\xa9\xcb\x13\xccL'
• [Core]: 03, [Random seed]: b'\xae7\xcaR\xf1\xda\x07\xc0\x06'
• [Core]: 05, [Random seed]: b"\xd1 \xa5\xc4\xcd'K\x8a\x9f"
• [Core]: 06, [Random seed]: b'u5\xfd\xe5\xe8\xd9\x0c\xd2\xc2'
• [Core]: 04, [Random seed]: b'\x91n\xbeN:\x00\xb5\xbfi'
• [Core]: 07, [Random seed]: b'\xf5\xbd\xe0Wh\xa3\xcb/#'
• [Core]: 08, [Random seed]: b'e@1\xec\x17d\xc5\xb9\xba'
• [Core]: 09, [Random seed]: b'\xab\xbd\xc0\xa7J9\x13\x1e\xae'
• [Core]: 10, [Random seed]: b'\x89\x8d\x07\x9c/s\xcc\x8b\xb8'
• [Core]: 11, [Random seed]: b'\xc0E\xc2\xdd\xc9\x9f\x8b]7'
• [Core]: 12, [Random seed]: b'\xd5{F\x006\xe6\x1c\xcc\xac'
• [Core]: 13, [Random seed]: b'%X81\n\x82\x97\x85\xdc'
• [Core]: 14, [Random seed]: b'm\x93\x95\xadg\xc9)\\\xd7'
• [Core]: 15, [Random seed]: b'L\xe3\x00\xd6Q\xa92\xf1\xb9'
• [Core]: 16, [Random seed]: b'\x95\xdaS\x1d\xbd\xc9\x84\x9d@'
• [Pindex]: 47101021642875518756392

i am trying your code still not found is there something like constant seed needs to write in code ?

[tmar777]

First 4 Bytes of all solved 20:3F puzzle... Someone Notice Something Here ?
https://www.talkimg.com/images/2023/12/12/EzmvT.gif

Puzzle: 02 frontHex: 00000003 Binary: 000000000000000000000000000011        Zeros: 0        Ones: 2 
Puzzle: 06 frontHex: 00000031 Binary: 000000000000000000000000110001        Zeros: 3        Ones: 3 
Puzzle: 10 frontHex: 00000202 Binary: 000000000000000000001000000010        Zeros: 8        Ones: 2 
Puzzle: 14 frontHex: 00002930 Binary: 000000000000000010100100110000        Zeros: 9        Ones: 5 
Puzzle: 18 frontHex: 0003080d Binary: 000000000000110000100000001101        Zeros: 12       Ones: 6 
Puzzle: 22 frontHex: 002de40f Binary: 000000001011011110010000001111        Zeros: 10       Ones: 12
Puzzle: 26 frontHex: 0340326e Binary: 000011010000000011001001101110        Zeros: 15       Ones: 11
puzzle: 30 frontHex: 3d94cd64 Binary: 111101100101001100110101100100        Zeros: 14        Ones: 16
puzzle: 34 frontHex: 34a65911 Binary: 110100101001100101100100010001        Zeros: 17        Ones: 13
puzzle: 38 frontHex: 22382fac Binary: 100010001110000010111110101100        Zeros: 16        Ones: 14
puzzle: 42 frontHex: 2a221c58 Binary: 101010001000100001110001011000        Zeros: 19        Ones: 11
puzzle: 46 frontHex: 2ec18388 Binary: 101110110000011000001110001000        Zeros: 18        Ones: 12
puzzle: 50 frontHex: 22bd43c2 Binary: 100010101111010100001111000010        Zeros: 16        Ones: 14
puzzle: 54 frontHex: 236fb6d5 Binary: 100011011011111011011011010101        Zeros: 11        Ones: 19
puzzle: 58 frontHex: 2c675b85 Binary: 101100011001110101101110000101        Zeros: 14        Ones: 16
puzzle: 62 frontHex: 363d541e Binary: 110110001111010101010000011110        Zeros: 14        Ones: 16

Do you see any pattern or something? I don't see something valuable here.

[nomachine]

why you can not solve 130 then with this code ?

Cause 130 isn't  60 i guess...

I keep 3600  as timeout for 130.

[AlanJohnson]

why you can not solve 130 then with this code ?

Cause 130 isn't  60 i guess...

I keep 3600  as timeout for 130.

I don't get what you are trying to do with your code, cause if your are trying to break a seed and get all the keys from deterministic wallet that not gonna work... It's like trying to crack 256 private key. Maybe i'm wrong so please enlighten me then.

[nomachine]

if your are trying to break a seed and get all the keys from deterministic wallet that not gonna work...

Something other than that. If you haven't seen what this script does, it's not worth explaining. Start in order from Puzzle 15.

[zahid888]

I have converted almost all Bitcoin addresses (P2PKH, P2SH) from base58 to hex and matched them with 40 million addresses. Below are some examples. Additionally, I have explored using these base58 values as a seed (from max-35 to min-8). Apart from this, I have also generated MD5, SHA1, SHA224, SHA256, SHA384[:64], SHA512[:64], BLAKE2B, and BLAKE2S hex values from these base58. Please refrain from attempting these and avoid wasting time.

Do you see any pattern or something? I don't see something valuable here.

I have noticed that there is a very small difference in each pair. And puzzle 66 is a pair of puzzle 70
So we have to make minor changes here

                 Puzzle 70


One more thing: every pair is smaller than its second, instead of only one pair.

puzzle: 34 frontHex: 34a65911 Binary: 110100101001100101100100010001        Zeros: 17        Ones: 13
puzzle: 38 frontHex: 22382fac Binary: 100010001110000010111110101100        Zeros: 16        Ones: 14

Based on this assumption 66 is smaller then 349b84b6...... Hope so.. .. If there are any other assumptions in someone's mind, they are welcome, because life is too short to guess even 30 bit.. 

[tmar777]

I have converted almost all Bitcoin addresses (P2PKH, P2SH) from base58 to hex and matched them with 40 million addresses. Below are some examples. Additionally, I have explored using these base58 values as a seed (from max-35 to min-8). Apart from this, I have also generated MD5, SHA1, SHA224, SHA256, SHA384[:64], SHA512[:64], BLAKE2B, and BLAKE2S hex values from these base58. Please refrain from attempting these and avoid wasting time.
https://www.talkimg.com/images/2023/12/24/Izsbj.png

Do you see any pattern or something? I don't see something valuable here.

I have noticed that there is a very small difference in each pair. And puzzle 66 is a pair of puzzle 70
So we have to make minor changes here

                 Puzzle 70
https://www.talkimg.com/images/2023/11/14/zTZS8.png

One more thing: every pair is smaller than its second, instead of only one pair.

puzzle: 34 frontHex: 34a65911 Binary: 110100101001100101100100010001        Zeros: 17        Ones: 13
puzzle: 38 frontHex: 22382fac Binary: 100010001110000010111110101100        Zeros: 16        Ones: 14

Based on this assumption 66 is smaller then 349b84b6...... Hope so.. .. If there are any other assumptions in someone's mind, they are welcome, because life is too short to guess even 30 bit.. 

Man, sorry it may be my brain that doesn't get it but I understand nothing.
"I have noticed that there is a very small difference in each pair. And puzzle 66 is a pair of puzzle 70 " in what pair do you refer to? pair mean there 2 things...
 "every pair is smaller than its second, instead of only one pair."
Also, can you provide a link to the binary graph that you use?

[nomachine]

life is too short to guess even 30 bit.. 

Everything is great up to 50bit. Above that, I either don't have enough CPU or RAM or the number of GPUs or all together. And I don't have money to rent 100 GPUs.

[citb0in]

And I don't have money to rent 100 GPUs.

even if you did, what would you hope to achieve?

[AlanJohnson]

life is too short to guess even 30 bit.. 

Everything is great up to 50bit. Above that, I either don't have enough CPU or RAM or the number of GPUs or all together. And I don't have money to rent 100 GPUs.

50bit ?   

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

[zahid888]

in what pair do you refer to?

       Pair - 1                    Pair - 2                   Pair - 3                     Pair - 4                    Pair - 5                     Pair - 6                    Pair - 7                   Pair - 8              Pair 9 Assumption
                 
Upon observing this, I bear no responsibility if someone's eyesight is adversely affected. LoL   Again, I would like to say that making assumptions instead of blindly following random numbers is not inherently negative, whether the outcome is favorable or not.

life is too short to guess even 30 bit..  

Everything is great up to 50bit. Above that, I either don't have enough CPU or RAM or the number of GPUs or all together. And I don't have money to rent 100 GPUs.

50bit ?  

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

Hmmm.. i can do this in a second

Pubkey : 026a6cb130f0f374bbe6cf5499cce541d2b2a86c1ca2007424547f686907f79c36
Address : 13z11bUYcdnHNn4NKwrxdf6r695YxKh5so
Range : 66 Bit

Someone put There fund i don't know what the helll he is trying to do.. you guys can sweep it.. https://blockchair.com/bitcoin/address/13z11bUYcdnHNn4NKwrxdf6r695YxKh5so

[mcdouglasx]

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

If you can handle 100 bits, why don't you solve puzzle #130? If I had that power I would have already found it.

[AlanJohnson]

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

If you can handle 100 bits, why don't you solve puzzle #130? If I had that power I would have already found it.

Cause estimated time for solving 100bit i have in DAYS while estimated time for 130bit i have in HUNDREDS OF YEARS. This shows how massive is the gap between these two ranges. People seems to not realize that.

[WanderingPhilospher]

Using Kangaroo i can solve every puzzle till 100 bit in very short time (of course im talking about puzzles where public key is available). Till 70 bit it's almost immediatley.

The problem is the range is getting exponetnially bigger to the extent it's just too big for current hardware (at least available for home users).

If you can handle 100 bits, why don't you solve puzzle #130? If I had that power I would have already found it.

Cause estimated time for solving 100bit i have in DAYS while estimated time for 130bit i have in HUNDREDS OF YEARS. This shows how massive is the gap between these two ranges. People seems to not realize that.

I mean it’s “only” 2^30 times bigger. 😂
So if you could solve 2^100 in a day, it would “only” take 1 billion days to solve 2^130.
That’s using traditional Kangaroo method only.
Maybe some ways you can shortcut it, but having enough equipment helps.