So the private key is starting with 37 in hex?

Thanks for your answer. It was a curiosity of how many addresses are untouched for more than 10 years.
From my point of view brute forcing of sha256 encrypted private keys is a waste of time.

Hi,

It's possible to add a column with the date of last spending tx?
Would be nice to identify the dormant addresses.
Thanks!

All the other mortals are spectators at the show created by Zielar and Jean Luc. I like the show. The show must go on

Hello,

@arulbero or others

I use below python script generator against pub keys. each core is using a random starting point for given keyspace.
From your experience, can be improved to be more faster?
Thanks!

#import random
import secrets
from bit import *
from bit.format import bytes_to_wif
from binascii import hexlify
import multiprocessing
from multiprocessing import Pool

print("Loading...")
with open("pub.txt","r") as m:
    add = m.read().split()
add= set(add)

#ran = secrets.randbits(253)
#ran = secrets.randbelow(115792089237316195423570985008687907852837564279074904382605163141518161494337)
#ran = random.randrange(1,115792089237316195423570985008687907852837564279074904382605163141518161494337)
ran = secrets.randbelow(115792089237316195423570985008687907852837564279074904382605163141518161494337)

r = 0
cores=2

def seek(r):
    while True:
        global ran
        key1 = Key.from_int(ran)
        wif = bytes_to_wif(key1.to_bytes(), compressed=False)
        key2 = Key(wif)
        pub1 = hexlify(key1.public_key).decode()
        pub2 = hexlify(key2.public_key).decode()
        myhex = "%064x" % ran
        if pub1 in add:
            print ("found!!!",ran, pub1)
            s1 = str(ran)
            s2 = pub1
            f=open(u"win.txt","a")
            f.write(s1)
            f.write(":"+s2)     
            f.close()
            break
        if pub2 in add:
            print ("found!!!",ran, pub2)
            s1 = str(ran)
            s2 = pub2
            f=open(u"win.txt","a")
            f.write(s1)
            f.write(":"+s2)     
            f.close()
            break
        else:
            print ("pubnr...", myhex, pub1)
            ran = ran + 1

if __name__ == '__main__':
        jobs = []
        for r in range(cores):
                p = multiprocessing.Process(target=seek, args=(r,))
                jobs.append(p)
                p.start()

How much he wants

Second round. All addressees are  from 2011. A total of aprox 3653 BTC.

Almost all of them are having input transactions of 0.00000888 BTC, 0.00000666 BTC or other similar values.

121PD8dUB7qV3iBti2oh749FB6ewKhrUVd
12Sw5TdWmhNBrp4aatyUbuwvjTWiGBN6Ud
15HFtBRHb1YBya59qqBh4ixERvpghqHPm9
163FHEwPo24J8qJpeGn49bfW1ZFvtveetg
17p9trUz5EEwdBS2w1RH2ZtuHmHFhWVzSh
186XnrNi2PaaaDkmR5Uy1ApJ6XEwjWyAGu
1cyWYR4WxXrXY18Exi6xwAPJaT18nPRfk
1DAq5ddQygy8FYxUv2GcnVG6do8kvxEBZM
1DvjpfhySgayHZbDtRkMLbYLyfHjQJfy6g
1Ehoz6WPFfVPgCJeifiPMirsVUYQ8So9oM
1GTKWmjYzVZbckw7WYkk4obadsTFACAHCp
1H4VEycmCNW3mxUMemYW68BKBM4giBkVLe
1KdypGFpuYc6RSiwon2LZkRasdjTM6TgMH
1QHQMWtQoJMouPrQHfJPHyqx9asvJTMRSP

Is not my script. I only wrote the first part of the script from the video, which is the generator but the second part which is most important was not revealed.
Will be released when the creator of the script will decide to do so.
Regarding speed there is on github pollard-kangaroo-c99 from Telariust with multicore ..up to 128 cores.

Doesn't have to delete any video. The first part of the script is useless/generic.

import collections
import time
import gmpy2
import random

EllipticCurve = collections.namedtuple('EllipticCurve', 'name p a b g n h')

curve = EllipticCurve(
    'secp256k1',
    p=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F,
    a=0,
    b=7,
    g=(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8),
    n=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141,
    h=1,
)

def pubkey_point(pubkey):

    if len(pubkey) == 130:
        hexpubX = pubkey[2:66]
        hexpubY = pubkey[67:130]
        X = int(hexpubX,16)
        Y = int(hexpubY,16)
        return (X, Y)
    else:
        hexpub = pubkey[2:66]
        prefix = pubkey[1:2]
        X = int(hexpub,16)
        Y = pow(int(X**3+7), int((curve.p+1)//4), int(curve.p))
        if Y%2 !=0:
            if int(prefix)%2 !=0:
                Y = Y
            else:
                Y = curve.p - Y
        else:
            if int(prefix)%2 ==0:
                Y = Y
            else:
                Y = curve.p - Y
        return (X, Y)

def point_neg(point):

    if point is None:
        return None
    x, y = point
    result = (x, -y % curve.p)
    return result

def point_add(point1, point2):

    if point1 is None:
        return point2
    if point2 is None:
        return point1
    x1, y1 = point1
    x2, y2 = point2
   
    if x1 == x2 and y1 != y2:
        return None
    if x1 == x2:
        #m = (3 * x1 *x1 + curve.a) * inverse_mod(2 * y1, curve.p)
        m = (3 * x1 *x1 + curve.a) * gmpy2.invert(2 * y1, curve.p)
    else:
        m = (y1 - y2) * gmpy2.invert(x1-x2, curve.p)
        #m = (y1 - y2) * inverse_mod(x1-x2, curve.p)
    x3 = m * m - x1 - x2
    y3 = y1 + m * (x3 - x1)
    result = (x3 % curve.p, -y3 % curve.p)
    return result

def scalar_mult(k, point):
    if k % curve.n == 0 or point is None:
        return None
    if k < 0:
        return scalar_mult(-k, point_neg(point))
    result = None
    power = ' '
    addend = point
   
    while k:
        if k & 1:
            result = point_add(result, addend)
        addend = point_add(addend, addend)
        k >>= 1
    return result

def make_keypair(intkey, point=curve.g):
    public_key = scalar_mult(intkey, point)   #random.randrange(1, curve.n)
    return public_key

if __name__ == '__main__':
   
    start = time.time()
    target_bit = 45
   
    while True:
        tb = random.randrange(1, 2**target_bit)
        if tb.bit_length()            pass
        else:
            target_pnt = make_keypair(tb)
            break
    print ('Target random:', tb)
    print ('Target random hex:', hex(tb))
   
    target_pnt = '026ecabd2d22fdb737be21975ce9a694e108eb94f3649c586cc7461c8abf5da71a'
    target_pnt = pubkey_point(target_pnt)

Sharing is caring

I want to understand how you found the solution for the below equation. Do you use some script?
Thanks!
Q + 13000000*G =
024154b506ab766f42fbe37f699976f84db89f4f2f6bed98325c1a0b6e326dd4e4 +
034d11d3fef403710f1332ae54d99d12e383e9ad1a87d3972ab737b0dffe359be7 =
02464e23afad4a987d1d7c93ffe1d2d1cd196b0c1999b76bf1225e229fd7a1e770

What is the value of the "G - basis point" ? Thanks!

Yeah. The puzzle of life. I want to solve a puzzle of 3000BTC to.

Something new will appear in one month aprox, after they will find 110 puzzle.
After that they will need something new because kangaroo will not find 115 in a reasonable time.

I have a list with dormant addresses around 2700 and I'm monitoring their activity for personal reasons.
Few days back I checked the balance on all of them and I saw that the funds were moved for some.

We don't know if is one person or a group. Also we don't know if is the owner..but it has the private keys.
The funds were only moved to other addresses.

I am not author of this collection ) LOL
What's the point? I don't get it. So grow up

I posted the info on a telegram group in 23 Oct. (me and drotika we are members in that group). drotika took the adressess and extracted the public keys and posted the info on the puzzle topic.
I have other 2700 dormant addresses and I'm monitoring their activity for months now.
I didn't had to transform anything from anything.

Hi,

All below addresses were emptied this year. Most of them in Sept. 2019. Around 2982 BTC in 21 addresses.
All addresses were first used in 2011, and dormant until now.
BCH is still there except 1 address.

No spending transactions on them so the public key was not known.
The owner he suddenly remembered after 8 years that he had some BTC?

12CpK8apTJfaMSiPYhGMDdaRRFYoS721Px
13GUJutC6GKgJQTcGzCtznDDYFQKVJFVwp
13Sa73PU9Ar5sE4SdFcBdbg9ntbNcMQhaA
14k4GhqA1svNZPbssdAjgdnfzWTpAigZVH
14nppk7sMVv91n1Nch6DQKaFto3wVmh8yT
16KVwFVDfU3DKrvnGGSM7hsGp3MnvHczuB
17tXBRCQzQz87zYetp3wwJRms4fcWN4a8v
18ws2qaW2xBRWGCmfjnDiDHa55A5iSJogP
18xEu7DB8u58ivNa3VwEFeEc4ZbjtMVtPD
19w2MURRz5LsjNHCckmp65YX4WCc7kJdJF
1APGxVLKXhXepeaAjV6z3s4d7xCYXXDwmj
1Aw7mXtLMDjTBNcaqjv6cT935BEQQr5vRF
1B3m4F831f9u6ySnpYbUwgriJAgS3tuso5
1BpqxJp2LEban4mJou5rDHYmzA9eTwKbXY
1CbvcQXEYrqXqbBczHL8to3xeVZ3EsgrhH
1DKwr32h5F6uuUmePdT7esZ21AfK7ovASK
1FRtwC64bWcMb7RGBcwLJTup6tYrCMs9ge
1HQT2UZEK4i3yHnYbVTaXNccgnM45th94f
1MtUY5R3xixWfthqrprVPWMMTwR5A7GU2x
1nYrmtXVjX9G3Q86tdKcKQRCq2MPVvNp9

What are your opinions?

Thank you for you answer. Most of us we are not native english speakers so your english is ok.
So this puzzle is a fight between coders. I`m not a coder but I wish good luck to all brilliant coders

@57e
What hardware did you used, CPU/GPU?
How long the discovery of private key took?
In your opinion the other keys up to a point can be found without huge resources?
I`m thinking that if huge resources are necessary only few people have access to huge amount of processing power.
Thanks!

It is possible that some private keys to be "outside" of the standard agreed key space? Somewhere where nobody will search?