Bitcoin Forum
June 18, 2024, 10:30:36 PM *
News: Voting for pizza day contest
 
  Home Help Search Login Register More  
  Show Posts
Pages: [1] 2 3 »
1  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: May 25, 2024, 07:31:02 PM
hi guys! who can help me to develop rust coding language?! (don't judge my statement and result, since i just new for learning this puzzle and trying new stuff)

i run this like 4-5 hours straight, i use pool keyspace and multi thread, the search only use CPU, let's find out can develop it with GPU power.

it's sequential and not random.

the thread is dividing key ranges and make the 1,5 bytes changed from left padding following how many thread are used.

  • Puzzle search
  • Script started at: 2024-05-25 20:56:03.700485 +07:00
  • from:0x23000000000000000 to:0x3ffffffffffffffff
  • target:13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
0000000000000000000000000000000000000000000000035200000002cc179e| 13zbaq4dADzLenZB6VdSdmAaqV8TABkHEf

average current speed is 15.000 Key/sec for each thread.

with some GPU power, i think my codes (?) can solve that in couple months.
my codes still make some bug, the address display is misleading the corresponding of private key, but it's still same prefix.
all of that still can search the matched, but the displaying of progress is not correct.
🙏🏻

example of pre-run.

000000000000000000000000000000000000000000000003c600000000002b0f  | 13zbpbczKXAcx9q4NvTuEa5szGu3 000000000000000000000000000000000000000000000003520000000000a039 | 13zbNacfa9Nrz8YttQbzLVqT7y4w 000000000000000000000000000000000000000000000003c60000000000d456 | 13zbFwGk1JussoSK3gax39256VBu 000000000000000000000000000000000000000000000002de000000000103a3 | 13zbt3NfsVUjJu8FQWxFfxdePAFP 0000000000000000000000000000000000000000000000026a00000000010bd3 | 13zbix1E22g4FRk5hUcoMV1Hhvpd 000000000000000000000000000000000000000000000002de0000000001333e | 13zbDQnUKS1N8AqmynykC1QYNgwc 000000000000000000000000000000000000000000000002de00000000013e02 | 13zb7xLuqjuPKdbGt7rshDEjdprK 00000000000000000000000000000000000000000000000352000000000168ae | 13zbm8dR61ur1GqnQEmjrRsM5knP 000000000000000000000000000000000000000000000002300000000001923c | 13zbpdWGSwZpHK2zyR2o5XqgfXdv 0000000000000000000000000000000000000000000000026a0000000001c928 | 13zbp7u1bEeK94RCMtsvuNtqBrYo 0000000000000000000000000000000000000000000000038c0000000001e94a | 13zb56DAy494Drdngk2YchYRNfvF 0000000000000000000000000000000000000000000000023000000000023728 | 13zbFaEpeoY7Hrx6sTLdM3ZvvUW5 0000000000000000000000000000000000000000000000031800000000023ade | 13zbtT9na4bJdYoexnZ6YSt6KDHp


my search techniques uses this
2^31 and 2^36
(36 bit)
MacBook-Pro:Desktop tepan$ python3 subs.py
Enter the range x: 31  
Enter the range y: 36

> 0x91000000 <

let's hunt.

    let begin: u128 = 0x910000000;
    let end: u128 = 0x9ffffffff;

const TARGET: &str = "1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1";


result :

  • Puzzle search
  • Script started at: 2024-05-26 02:25:21.816449 +07:00
  • from:0x910000000 to:0x9ffffffff
  • target:1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1

 00000000000000000000000000000000000000000000000000000009f7a02888| 1Be2JoBBasXePHijh1AD1FK5Wsui 00000000000000000000000000000000000000000000000000000009f3702fc4| 1Be2m52dDvKNf2wrvbvSoh4V4t8Q 00000000000000000000000000000000000000000000000000000009e2b0702a| 1Be2DebJWkfJWXb8cszjA8mN6fvh 00000000000000000000000000000000000000000000000000000009e6e07a23| 1Be2wkS3jkyDGWnVpiNXVzUYdTtY 00000000000000000000000000000000000000000000000000000009eb10e589| 1Be2f5NaU8Qv35nPzJk4S6Jntzvs 00000000000000000000000000000000000000000000000000000009fbd0fcef| 1Be2uQTHQC5V9QPTqSkHvGNpFA5H 00000000000000000000000000000000000000000000000000000009e2b117d2| 1Be2nTuUQDYvYgyHPfE6S4hBTVNc 00000000000000000000000000000000000000000000000000000009eb119a5e| 1Be2ncy8U6oS9UzUGQU13CW7prqo 00000000000000000000000000000000000000000000000000000009f371a027| 1Be2tHcpUiDPVcqdvu2v2KmtA1m9 00000000000000000000000000000000000000000000000000000009e6e1b74a| 1Be22Wi2usp5z2J1wRvfovS8pD7R 00000000000000000000000000000000000000000000000000000009fbd1be53| 1Be2eU7ktk7abQsFRHgVP1qmmpZW 00000000000000000000000000000000000000000000000000000009f371d249| 1Be2zLYgYPdSjL9cog8kCsWUVjax 00000000000000000000000000000000000000000000000000000009f7a1e133| 1Be2xv3Q6XtLnBAz4SmbqbaSkhs8 00000000000000000000000000000000000000000000000000000009de820a7c| 1Be2UF9NLfyLFbtm3TCbmuocc9N1 00000000000000000000000000000000000000000000000000000009e2b20b15|
  • --------------------------------------------------------------------------------
  • KEY FOUND! 2024-05-26 02:29:44.164813 +07:00
  • private key (WIF): KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9Mg1Upu7eJAtiDr
  • private key (hex): 00000000000000000000000000000000000000000000000000000009de820a7c
  • public key: 02b3e772216695845fa9dda419fb5daca28154d8aa59ea302f05e916635e47b9f6
  • address: 1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1
  • --------------------------------------------------------------------------------
  • Search completed Smiley


it's like 3 minutes for search by address.



look at this, example of use.

34   2^33...2^34-1   200000000...3ffffffff | x : 29 y: 34 - > > 0x330000000 < [ 0x330000000:0x3ffffffff ] [found on 0x34a65911d ]

38   2^37...2^38-1   2000000000...3fffffffff | x : 33 y: 38 - > > 0x2100000000 < [0x2100000000:0x2ffffffffff] [found on 0x22382facd0 ]

.. etc
i make this premature codes for saving more times with lowkey cpu speed for search, but work until 79 bit, rest of that, the output result for keyspace is not correct.
sorry i cant provide the real codes, because someone can brute that easily with his huge mining GPU farm Smiley

2  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: May 25, 2024, 07:05:37 PM
hi guys! who can help me to develop rust coding language?! (don't judge my statement and result, since i just new for learning this puzzle and trying new stuff)

i run this like 4-5 hours straight, i use pool keyspace and multi thread, the search only use CPU, let's find out can develop it with GPU power.

it's sequential and not random.

the thread is dividing key ranges and make the 1,5 bytes changed from left padding following how many thread are used.

  • Puzzle search
  • Script started at: 2024-05-25 20:56:03.700485 +07:00
  • from:0x23000000000000000 to:0x3ffffffffffffffff
  • target:13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
0000000000000000000000000000000000000000000000035200000002cc179e| 13zbaq4dADzLenZB6VdSdmAaqV8TABkHEf

average current speed is 15.000 Key/sec for each thread.

with some GPU power, i think my codes (?) can solve that in couple months.
my codes still make some bug, the address display is misleading the corresponding of private key, but it's still same prefix.
all of that still can search the matched, but the displaying of progress is not correct.
🙏🏻

example of pre-run.

000000000000000000000000000000000000000000000003c600000000002b0f  | 13zbpbczKXAcx9q4NvTuEa5szGu3 000000000000000000000000000000000000000000000003520000000000a039 | 13zbNacfa9Nrz8YttQbzLVqT7y4w 000000000000000000000000000000000000000000000003c60000000000d456 | 13zbFwGk1JussoSK3gax39256VBu 000000000000000000000000000000000000000000000002de000000000103a3 | 13zbt3NfsVUjJu8FQWxFfxdePAFP 0000000000000000000000000000000000000000000000026a00000000010bd3 | 13zbix1E22g4FRk5hUcoMV1Hhvpd 000000000000000000000000000000000000000000000002de0000000001333e | 13zbDQnUKS1N8AqmynykC1QYNgwc 000000000000000000000000000000000000000000000002de00000000013e02 | 13zb7xLuqjuPKdbGt7rshDEjdprK 00000000000000000000000000000000000000000000000352000000000168ae | 13zbm8dR61ur1GqnQEmjrRsM5knP 000000000000000000000000000000000000000000000002300000000001923c | 13zbpdWGSwZpHK2zyR2o5XqgfXdv 0000000000000000000000000000000000000000000000026a0000000001c928 | 13zbp7u1bEeK94RCMtsvuNtqBrYo 0000000000000000000000000000000000000000000000038c0000000001e94a | 13zb56DAy494Drdngk2YchYRNfvF 0000000000000000000000000000000000000000000000023000000000023728 | 13zbFaEpeoY7Hrx6sTLdM3ZvvUW5 0000000000000000000000000000000000000000000000031800000000023ade | 13zbtT9na4bJdYoexnZ6YSt6KDHp
3  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: May 17, 2024, 12:34:06 AM
for your information guys, this puzzle has same pattern like this address doing the transaction.

1VayNert3x1KzbpzMGt2qdqrAThiRovi8

proof of
https://www.blockchain.com/explorer/transactions/btc/9969603dca74d14d29d1d5f56b94c7872551607f8c2d6837ab9715c60721b50e
https://www.blockchain.com/explorer/transactions/btc/8c8baf2e0529c0193ad3a583306a16fcc3e9cd271ba625e12bfd74261a46ad7c

Total Received
25467612.38364991 BTC
$1,666,432,468,144

Total Sent
25467612.13780228 BTC
$1,666,432,452,057

all those transactions seem to have the same ways generate password/OP codes, too, so he would need to spend all of them at the same time.

and back to 04/16/2023, that address was sending some amount to this address bc1quksn4yxlxp80tn929gqnh8xpnngqj0fqr99q4z (not directly), with some scrambled transaction involves many address.
4  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: May 14, 2024, 05:11:22 PM
Geniuses who found the key for address #66, can you tell me if the key is between 37396512239913013824 and 51680708854858323072?


The hexadecimal approximately probably 16.12% to found within the 66 bit range.  Roll Eyes
 
2B85F409A58861B43 into 3ffffffffffffffff  Huh

169,549,060,031,553,553,727.  Shocked


guess that big number.  Grin
5  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: May 10, 2024, 07:58:55 AM
I can't squeeze out more than 852.000 affine point additions per second


I have 249457 hops per second in python  converting this script with cpython into .so

Code:
import time
import os
import sys
import random
import secp256k1 as ice
import gmpy2

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[+] Kangaroo: {t}\n")
sys.stdout.flush()

modulo = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
order = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
Gx = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
Gy = gmpy2.mpz(0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8)

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

PG = Point(Gx, Gy)
Z = Point(0, 0)  # zero-point, infinite in real x, y - plane

def add(P, Q, p=modulo):
    if P == Z:
        return Q
    elif Q == Z:
        return P
    elif P.x == Q.x and (P.y != Q.y or P.y == 0):
        return Z
    elif P.x == Q.x:
        m = (3 * P.x * P.x) * gmpy2.invert(2 * P.y, p) % p
    else:
        m = (Q.y - P.y) * gmpy2.invert(Q.x - P.x, p) % p
  
    x = (m * m - P.x - Q.x) % p
    y = (m * (P.x - x) - P.y) % p
    return Point(x, y)

def mul2(P, p=modulo):
    if P == Z:
        return Z
    m = gmpy2.f_mod(3 * P.x * P.x * gmpy2.invert(2 * P.y, p), p)
    x = gmpy2.f_mod(m * m - 2 * P.x, p)
    y = gmpy2.f_mod(m * (P.x - x) - P.y, p)
    return Point(x, y)

def mulk(k, P=PG, p=modulo):
    if k == 0:
        return Z
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, mul2(P, p), p)
    else:
        return add(P, mulk((k - 1) // 2, mul2(P, p), p), p)

def X2Y(X, y_parity, p=modulo):
    X_cubed = gmpy2.powmod(X, 3, p)
    X_squared = gmpy2.powmod(X, 2, p)
    tmp = gmpy2.f_mod(X_cubed + 7, p)
    Y = gmpy2.powmod(tmp, gmpy2.f_div(gmpy2.add(p, 1), 4), p)
    if y_parity == 1:
        Y = gmpy2.f_mod(-Y, p)
    return Y


def comparator(A, Ak, B, Bk):
    result = set(A).intersection(set(B))
    if result:
        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)
        total_time = time.time() - starttime
        print('\n[+] total time: %.2f sec' % (total_time))
        t = time.ctime()
        print(f"\033[32m[+] PUZZLE SOLVED: {t} \033[0m")
        print(f"\033[32m[+] Private key (wif) Compressed : {wifc} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nSOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.2f} sec")
            file.write(f"\nRandom seed: {seed}")
            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"
            )
        file.close()
        return True
    else:
        return False

def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    if P.x % DP_rarity == 0:
        A.append(gmpy2.mpz(P.x))
        Ak.append(gmpy2.mpz(Pindex))
        return comparator(A, Ak, B, Bk)
    else:
        return False

# Generate a list of powers of two for faster access

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

def search(P, W0, DP_rarity, Nw, Nt, hop_modulo, upper_range_limit, lower_range_limit, powers_of_two):
    solved = False
    t = [gmpy2.mpz(lower_range_limit + gmpy2.mpz(random.randint(0, upper_range_limit - lower_range_limit))) for _ in range(Nt)]
    T = [mulk(ti) for ti in t]
    dt = [gmpy2.mpz(0) for _ in range(Nt)]
    w = [gmpy2.mpz(random.randint(0, upper_range_limit - lower_range_limit)) for _ in range(Nw)]
    W = [add(W0, mulk(wk)) for wk in w]
    dw = [gmpy2.mpz(0) for _ in range(Nw)]
    print('[+] tame and wild herds are prepared')
    Hops, Hops_old = 0, 0
    t0 = time.time()  
    while not solved:
        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: break
            t[k] += dt[k]
            T[k] = add(P[int(pw)], T[k])
        if solved: break
        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: break
            w[k] += dw[k]
            W[k] = add(P[int(pw)], W[k])
        if solved: break
        t1 = time.time()
        if (t1 - t0) > 5:
            print('\r[+] Hops: %.0f h/s' % ((Hops - Hops_old) / (t1 - t0)), end='', flush=True)
            t0 = t1
            Hops_old = Hops
    print('[+] Hops:', Hops)
    return 'sol. time: %.2f sec' % (time.time() - starttime)

puzzles = [\
    ('0209c58240e50e3ba3f833c82655e8725c037a2294e14cf5d73a5df8d56159de69',32),\
    ('03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4',40),\
    ('025e466e97ed0e7910d3d90ceb0332df48ddf67d456b9e7303b50a3d89de357336',44),\
    ('026ecabd2d22fdb737be21975ce9a694e108eb94f3649c586cc7461c8abf5da71a',45),\
    ('03f46f41027bbf44fafd6b059091b900dad41e6845b2241dc3254c7cdd3c5a16c6',50),\
    ('0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b',65),\
    ('03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852',130)]

puzzle = 40
for elem in puzzles:
    s, n = elem
    if puzzle == n: break

kangaroo_power = 4
DP_rarity = 1 << int(((puzzle -  2*kangaroo_power)/2 - 2))
hop_modulo = ((puzzle - 1) // 2) + kangaroo_power
Nt = Nw = 2**kangaroo_power

X = gmpy2.mpz(s[2:66], 16)
Y = X2Y(X, gmpy2.mpz(s[:2]) - 2)

W0 = Point(X,Y)
starttime = oldtime = time.time()
search_range = 2**(puzzle-1)

lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2 ** puzzle) - 1

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

# Precompute powers of two for faster access
powers_of_two = generate_powers_of_two(hop_modulo)

# Initialize variables
T, t, dt = [], [], []
W, w, dw = [], [], []

#Random seed Config
seed = os.urandom(9)
print(f"[+] [Random seed]: {seed}")
random.seed(seed)

Hops = 0
N_tests = 1

P = [PG]
for k in range(255): P.append(mul2(P[k]))  
print('[+] P-table prepared')

for k in range(N_tests):
    solved = False
    search(P, W0, DP_rarity, Nw, Nt, hop_modulo, upper_range_limit, lower_range_limit, powers_of_two)

print('[+] Average time to solve: %.2f sec' % ((time.time()-starttime)/N_tests))

It normally goes to 207301 h/s

Imagine this in Rust, how fast would it go? Grin


u128
const uint64_t
uint64 in C & u128 in Rust not work for Puzzle 130 (try to deal with dinosaur numbers)

BigUint/BIGINT from SSL works or GMP can be used Wink

okay good information here, i'll learn that for P#130, thankyou.
6  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: May 08, 2024, 06:36:17 AM
Experiments with your python codes on rust language


You have here my full Puzzle sctipt in Rust:
https://bitcointalk.org/index.php?topic=1306983.msg63539973#msg63539973
It's very fast. Same as C++
But when you put Puzzle 66 and above as a test, everything is slow. Without a public key, I can only scratch my head.

ahahah soo hilarious.

Try test with custom script address build then, it's faster.
private key > Compresssed public key > custom script > address format.

i try that method it's faster enough.
7  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: May 07, 2024, 12:53:58 PM
There are algorithms that are actually getting the uniform real randomness (not some deterministic PRNG bullshit like someone mentioned earlier, I mean really lol? Haven't they heard about os.urandom and how it works?)

Code:
import os, sys, random
import time

min_range = 18446744073709551615
max_range = 36893488147419103231
counter = 0  # Initialize counter
start_time = time.time()

while True:
    random_bytes = os.urandom(9)
    initial_bytes = b'\x00' * 23
    full_bytes = initial_bytes + random_bytes
    dec = int.from_bytes(full_bytes, byteorder='big')
    counter += 1  # Increment counter
    message = "\rPrivate Keys per second: {:.2f}".format(counter / (time.time() - start_time))
    messages = []
    messages.append(message)
    output = "\033[01;33m" + ''.join(messages) + "\r"
    sys.stdout.write(output)
    sys.stdout.flush()
    if min_range <= dec <= max_range:
       if dec == 30568377312064202855:
          print("\nSeed :", random_bytes)
          print("Generated number:", dec)
          break

This is Python script that will test os.urandom speed.
The example works for Puzzle 65. There is no hash or secp256k1 operations here - just numbers.
Result is (on my PC) :
Private Keys per second: 170893.39

Do you know how many numbers need to be generated per second to find Puzzle 65 in 10 minutes?

30744573456182586  Private Keys per second !

It's an mission impossible . Even in C++

We need Grey aliens hardware to solve this. From Zeta Reticuli  Grin

Experiments with your python codes on rust language

use std::time::{Instant, Duration};
use std::io::{self, Write};

const UPDATE_INTERVAL: u64 = 1000000; // Update progress every 1 million iterations

fn main() {
    // Input minimum and maximum ranges in hexadecimal format
    let min_range_hex = "100000000";
    let max_range_hex = "1ffffffff";

    // Convert hexadecimal strings to u128 values
    let min_range: u128 = u128::from_str_radix(min_range_hex, 16).unwrap();
    let max_range: u128 = u128::from_str_radix(max_range_hex, 16).unwrap();

    let start_time = Instant::now();
    let mut counter = 0u64;

    let stdout = io::stdout();
    let mut handle = stdout.lock();

    for num in min_range..=max_range {
        counter += 1;

        if counter % UPDATE_INTERVAL == 0 || num == max_range {
            print_progress(&mut handle, num, counter, start_time.elapsed());
        }

        // Break the loop if the generated number matches a specific value
        if num == 0x1a96ca8d8 {
            writeln!(&mut handle, "\nGenerated number (decimal): {}", num).unwrap();
            break;
        }
    }
}

// Function to print progress to stdout
fn print_progress(handle: &mut io::StdoutLock, num: u128, counter: u64, elapsed_time: Duration) {
    let private_keys_per_second = counter as f64 / elapsed_time.as_secs_f64();
    let hex_representation = format!("{:#X}", num);

    // Move cursor to the beginning of the line and clear it
    print!("\r\x1B[K");

    // Write the output to stdout in a single line
    print!("{} | {:.2} keys/s", hex_representation, private_keys_per_second);
    handle.flush().unwrap();
}


Result
0x1A96CA8D8 | 82762283.93 keys/s
Generated number (decimal): 7137437912


single thread, M2 Proc.
8  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: May 05, 2024, 03:52:29 AM
wish me luck, current speed is 100K keys per sec.

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



Nice info, but i already know from year past about that Alberto's BSGS.
9  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: May 05, 2024, 03:49:51 AM

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

It must be a joke! You're joking, aren't you? Grin

😂🥶🤫
10  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: May 04, 2024, 03:00:12 PM
| 38F6219EE3A3D85D4 | 13zb1P1kw3PyhCiwD3UNpD84fx2axrJhdv   | 20d4593f55c6ad7c26ec814666fce11c74c26240 |
| 22EB598FC469C5C0C | 13zb1WBV2Z48YuUnqEeSMa3a5P4GTMNBXw   | 20d459b3e617ee5b2f4a0ade3489c74e18ae6726 |
| 31D5E00B519D1D343 | 13zb1cs4B4gNiq87JnSNub9o51qtvFFE6G   | 20d45a2091876e79ea6a59f6702d6541b46887a2 |  
| 20C79DCD75513ADA1 | 13zb1iQ3mvS8s4JxBfrT4VU3Kct49jR8z2   | 20d45a7a920ba6f3362cfc5a9a708b717947f31a |
| 340FAE4332F3F93F3 | 13zb1au9kvqRGr497sGb3hoY11NdtZTzHo   | 20d45a00a1a6976e5b3a70ac3ec54387495f799b |
| 3CD7796DC62D738D6 | 13zb1BJZdLWFXnY8opAHtC7tEYKuAx7UY6   | 20d45880e5f2775bef64b160083c7f70ad4e4a2b |
| 3C661DD146906999C | 13zb14dzagJSAs8ExAxiVURvK4hxHGBSvr   | 20d45814826a5130c6b6e99846eefb7b29b08966 |
| 2570B465E2E2B7539 | 13zb1gj8kjC8BcPiLQchHiUYCP7whomxQK   | 20d45a5f65a8db614542cb063ba508920e8294c7 |
| 3512F971A039784C3 | 13zb111npnaATyQibmmhyGo4gyBBgLcB2g   | 20d457d9924eb254900aab37b690f42e3794deb3 |
| 2E4115FFD6DED498D | 13zb1NJoKk8QNVq39ovmvmTP6Qczi6QdEN   | 20d45933d9cd875940a19674e419891c4e1965e7 |
| 2FC3BE3D049B93B5C | 13zb1df5wTfUxc8DCE2FguuX9HRqniUvrj   | 20d45a2d798a79492525fb7c58802c00c99f3c7d |
| 273FD355C07294A64 | 13zb1MeqFdsnQgszDHxyaVLGBmjXL5ikQo   | 20d45929349816c3327f2be99df4595f1653538b |
| 200DAE45EAC5DF2A5 | 13zb16nndRPtF5z6W253AaJ8tmyb2M9hrf   | 20d458377ffaa3c1fb8b5f38d8ae0a1b1a759d15 |
| 28CA317317998B18B | 13zb11DtFvnKEDqSCc1KEMMj6xo16QxFHc   | 20d457dcf660bc47dcd9e54b6fbc36d90a239338 |
| 34E3010DE01C74869 | 13zb1JNs7GtHcpxLEdjhGq6mxnGSHga37d   | 20d458f3f0e8de9ae3711ddbcb843f506dbe7197 |
| 219478B3A52F0735F | 13zb1qhSuRqytgNHBU4aZ2WRNhjVURarVf   | 20d45af1491f5d903895555f040353db14414ed3 |
| 2355254DEE6FCDFF6 | 13zb1yUcbaQfieXJ74pKCZaH4CWiD5bkf2   | 20d45b6fc960b83900f812c21028e77c3da9e126 |
| 3A41C7D979F1BAC9D | 13zb1hidRcTS6S737V8FT5PfazHTU4oX2f   | 20d45a6f84891560f096a6726eeae68fe51277dc |
| 3AA5DA3B2B0279D80 | 13zb14sfH99jTZKTwVvtavCpheZ5fZjGrV   | 20d45818576e6483f52ea575422e2b80a5683f7b |
| 250F27D26FF94B3CA | 13zb1VotqWUouo7HmtaatUKcFsMtv6tkJk   | 20d459add86cbcb25a1d8fbd0db2cf62365b3d04 |

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


just currently update my progress, because i rarely active since i need someone help to translate my rust code into C++.
Smiley
11  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: February 08, 2024, 10:40:02 AM

sure, i'll dm you, btw your codes looks cool and more advanced!
wow!, i'm beginner can you teach ?!


Sure, I'll see what else i can do to improve your code.

i already make some display looks clean and more likely like your display codes on terminal



i'll send the python files, i hope you can help me Wink, thanks!
12  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: February 08, 2024, 04:11:16 AM
Quote
sure, i'll dm you, btw your codes looks cool and more advanced!
wow!, i'm beginner can you teach ?!

#EDIT
from my codes provide chance to find the 66 puzle is on 3000000000000000:37fffffffffffffff , below that it's just give same result hash and different 13zb1 address derived from private key. (but it's just speculation.)

Tepan, you seem hesitant to share your code, but trust me, what you are doing has already been done, in a much faster programming language, C++; CPU and GPU versions, where you can provide a h160 or address prefix and it will find EVERY collision in a 40 bit range, in less than a minute (depending on GPU setup).

Your python script may have some different settings/search criteria, but the bottom line is the same.

People are trying to help you speed up your code, in python, because your code is extremely slow. If your python code isn't checking at least 250,000 keys per second, then it desperately needs an overhaul. I can create a python script to do what yours is doing, that will check at least 250,000 keys per second, python only, single core, in less than 10 minutes.

But hey, you do you.

Zahid888, is the expert at prefix searches...probably has the world's largest prefix database, he can attest to what I am saying to you.

no, i'm not hesitant to share my codes, because don't have much time, i know what i'm working on it clearly someone’s has been done before.
 i'll dm you and zahid888, soon.
13  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: February 07, 2024, 06:07:54 PM
@Tepan, could you implement KNN algorithm to your script?  it could somewhat help you in predicting a clearer pattern in order to create a map of similar hashes in certain ranges.

You could scan 39 to 40 bit range and categorize similarly found hashes,  do that with different hash prefixes in different bit ranges,  you might figure out the average probability of certain hashes existing in specific ranges.

Note that KNN algo is a great tool for statistics.  it stands for k-nearest neighboring.

>> test.py 18ZRLg9BMfAg9WYVWqVDtYdT59QV1PzrJe 18Z 52ea8235174b368df646576fc04eb0d2737057b6 1a000000000000000 1afffffffffffffff

000000000000000000000000000000000000000000000001a6f7e55277418662 | Hash 160 52ffb5fad1e2964e0d62d0fb1fba1b2a51959602 | 18ZrjqFukCHggGmF9NHvTHnypz8CWUiesG | 600.90 sec |
000000000000000000000000000000000000000000000001a698bf0141abba89 | Hash 160 52faf3bd9c45c9788dd66c1c3247b9861149342c | 18Zm3BwAm4CNym3KuUUZu3n3vytQ6TXRoU | 700.29 sec |
000000000000000000000000000000000000000000000001a61adda168bf1479 | Hash 160 5304d1f3f9a3e5d191a70656b8cd49f242d91e8e | 18ZxrqALETxJS5eQ834BD8xdLBuLzDztqA | 700.61 sec |
000000000000000000000000000000000000000000000001a64271593ec75f14 | Hash 160 52df324fdd87f86fb67bd415db3fd3c63d70d5a2 | 18ZBnhRYcHxdw4fSDByCb7tMqnCA1n9UxC | 700.87 sec |
000000000000000000000000000000000000000000000001a678bde0e606d586 | Hash 160 52ea8235174b368df646576fc04eb0d2737057b6 | 18ZRLg9BMfAg9WYVWqVDtYdT59QV1PzrJe | 800.39 sec |
000000000000000000000000000000000000000000000001a7d696f300cda2fc | Hash 160 52db4611541a1d382a06279c0a32b45bd1a0bf2b | 18Z768mmb7LCGDjU5xsF5YtPiSvRo5pVvR | 900.63 sec |
Similar hash160 found: 52ea8235174b368df646576fc04eb0d2737057b6

=========[Address Found]===========
Private Key: 000000000000000000000000000000000000000000000001a678bde0e606d586
Hash 160: 52ea8235174b368df646576fc04eb0d2737057b6
Address: 18ZRLg9BMfAg9WYVWqVDtYdT59QV1PzrJe
0x1a678bde0e606d586
Compressed Public Key: 02f46cb94bfecf5daf63cd54353c73eb3f7e148ac0f9b8af46e3a94ee8b60e1260
Time taken to find: 0.0000 seconds
Speed of keys: 0.0000 keys per second
=========[Address Found]===========

thankyou for advice, i make the KNN algorithm work with my previous code but have some trouble with other codes, some confusion call the rest codes to work with scan range, but it's work.
i test on 65 bit.

mightbe push my luck for 66 for couple weeks.



Can i take a look at your code ?

sure, i'll dm you, btw your codes looks cool and more advanced!
wow!, i'm beginner can you teach ?!

#EDIT
from my codes provide chance to find the 66 puzle is on 3000000000000000:37fffffffffffffff , below that it's just give same result hash and different 13zb1 address derived from private key. (but it's just speculation.)
14  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: February 07, 2024, 05:55:09 PM
@Tepan, could you implement KNN algorithm to your script?  it could somewhat help you in predicting a clearer pattern in order to create a map of similar hashes in certain ranges.

You could scan 39 to 40 bit range and categorize similarly found hashes,  do that with different hash prefixes in different bit ranges,  you might figure out the average probability of certain hashes existing in specific ranges.

Note that KNN algo is a great tool for statistics.  it stands for k-nearest neighboring.

>> test.py 18ZRLg9BMfAg9WYVWqVDtYdT59QV1PzrJe 18Z 52ea8235174b368df646576fc04eb0d2737057b6 1a000000000000000 1afffffffffffffff

000000000000000000000000000000000000000000000001a6f7e55277418662 | Hash 160 52ffb5fad1e2964e0d62d0fb1fba1b2a51959602 | 18ZrjqFukCHggGmF9NHvTHnypz8CWUiesG | 600.90 sec |
000000000000000000000000000000000000000000000001a698bf0141abba89 | Hash 160 52faf3bd9c45c9788dd66c1c3247b9861149342c | 18Zm3BwAm4CNym3KuUUZu3n3vytQ6TXRoU | 700.29 sec |
000000000000000000000000000000000000000000000001a61adda168bf1479 | Hash 160 5304d1f3f9a3e5d191a70656b8cd49f242d91e8e | 18ZxrqALETxJS5eQ834BD8xdLBuLzDztqA | 700.61 sec |
000000000000000000000000000000000000000000000001a64271593ec75f14 | Hash 160 52df324fdd87f86fb67bd415db3fd3c63d70d5a2 | 18ZBnhRYcHxdw4fSDByCb7tMqnCA1n9UxC | 700.87 sec |
000000000000000000000000000000000000000000000001a678bde0e606d586 | Hash 160 52ea8235174b368df646576fc04eb0d2737057b6 | 18ZRLg9BMfAg9WYVWqVDtYdT59QV1PzrJe | 800.39 sec |
000000000000000000000000000000000000000000000001a7d696f300cda2fc | Hash 160 52db4611541a1d382a06279c0a32b45bd1a0bf2b | 18Z768mmb7LCGDjU5xsF5YtPiSvRo5pVvR | 900.63 sec |
Similar hash160 found: 52ea8235174b368df646576fc04eb0d2737057b6

=========[Address Found]===========
Private Key: 000000000000000000000000000000000000000000000001a678bde0e606d586
Hash 160: 52ea8235174b368df646576fc04eb0d2737057b6
Address: 18ZRLg9BMfAg9WYVWqVDtYdT59QV1PzrJe
0x1a678bde0e606d586
Compressed Public Key: 02f46cb94bfecf5daf63cd54353c73eb3f7e148ac0f9b8af46e3a94ee8b60e1260
Time taken to find: 0.0000 seconds
Speed of keys: 0.0000 keys per second
=========[Address Found]===========

thankyou for advice, i make the KNN algorithm work with my previous code but have some trouble with other codes, some confusion call the rest codes to work with scan range, but it's work.
i test on 65 bit.

mightbe push my luck for 66 for couple weeks.
15  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: February 07, 2024, 03:52:06 PM
i do some Experiment, trial and error for 66 bit

Let's say i take one 66 bit address for practice
000000000000000000000000000000000000000000000002be7989dd1a1a63ad | Hash 160 20cb77af1a425c5e74483d9b30cf950911a090de | 13zQNJwpREZogcPSkNJmYQzZ9HZQZS48Hx [TARGET]

result scan :
000000000000000000000000000000000000000000000002b809677889fb1078 | Hash 160 20cb78b594b77cf97259be5cc414f0a49f1bde81 | 13zQNb5x4P7vCjag18rZKCVHkBcqtddaLS | 102.92 sec | 136.0 keys/sec |
00000000000000000000000000000000000000000000000285a7e79fd01fc2a4 | Hash 160 20cbc445f68147eb89314c6710de2a7c5fc2e0fb | 13zQj6btR6awFjac835xsvDqeCtVyioiiW | 112.67 sec | 124.9 keys/sec |
000000000000000000000000000000000000000000000002757de2916bb72c92 | Hash 160 20cbc889d5186984e2189dd818e67d990f992459 | 13zQkFk3v2WXrhLVVhP2NKM1JT4Gbd6VoY | 153.39 sec | 110.4 keys/sec |
000000000000000000000000000000000000000000000002a6bdd8aaca2a5a56 | Hash 160 20cbb6398c3a2a9ad13eec60d2ffd84ed113d96d | 13zQfHTEd9EZncjXmiKMoZV7SqSZP39myL | 159.93 sec | 100.8 keys/sec |


I'm very grateful the result seem make some chance to hit the targeted and correct key
000000000000000000000000000000000000000000000002b809677889fb1078 | Hash 160 20cb78b594b77cf97259be5cc414f0a49f1bde81 | 13zQNb5x4P7vCjag18rZKCVHkBcqtddaLS | 102.92 sec | 136.0 keys/sec |

i make some checkpoint rules and check if at least 10 addresses have similarity in hash160 derived from private key.

What result are you talking about? I'm sorry if I can't see the wood for the trees, but I see absolutely nothing here that can be helpful in any way that relates to the topic of finding the puzzle. I see you have defined a target and I see you have listed four private keys and the corresponding addresses. There is no relation between them, how could there be, it wouldn't make any sense.

So what exactly did you find out or what makes you think that you're on the right track? Please don't misunderstand me, but I only see random data here without any relation to anything.

Did you know the work of bitcoin address, my codes to search the puzzle to sink the large private key range bro, random data ? it's calculated, the private key generate public key, and hash160 was from public key of address, the "20cb78" of hash 160 from 13zQNfHTEd9EZncjXmiKMoZV7SqSZP39myL is on range "2a6bdd8aaca2a5a56".

hash 160 of 13zQNJwpREZogcPSkNJmYQzZ9HZQZS48Hx is "20cb77af1a425c5e74483d9b30cf950911a090de", take a look "20cb78" and "20cb77" It doesn't look that far away from the hash160 generated from the private key.

if you change the 78 into 78 it make lot of changes on address.
20cb77af1a425c5e74483d9b30cf950911a090de : 13zQN JwpREZogcPSkNJmYQzZ9HZQZS48Hx
20cb78af1a425c5e74483d9b30cf950911a090de : 13zQN agqxpgJMoqzrF3SUvYVq82ENKem4J


so the work of codes is when found that similiarities it will change the range of private key e.g 2a6bdd8aaca2a5a56 to 3ffffffffffffffff


the technical i learn is from https://learnmeabitcoin.com/technical/address, you change some number/letter on hash160 it's generate the different Bitcoin Address, but in other ways, we don't know what coresponding private key from that changes.

so what i do is collision hash160, it's like changes the private key start range to end range, when similiarities found.

i will preview the codes, the most unique is i make something new for search proccess and work on puzzle 40 bit within 18 second with that codes, it's not completed by speed, but by math from collision hash160.
and if u ask ? why not complete the 66 puzle, it's hard because i need to configure anything on that codes, because if there's mistaken value input for search, the proggress can be exhausted.

but thank you for your response, even though you don't help anything in the development I do, it's just criticism regarding someone's proggress in this community.
16  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: February 07, 2024, 12:13:40 PM
Quote
Let's say i take one 66 bit address for practice
000000000000000000000000000000000000000000000002be7989dd1a1a63ad | Hash 160 20cb77af1a425c5e74483d9b30cf950911a090de | 13zQNJwpREZogcPSkNJmYQzZ9HZQZS48Hx [TARGET]

result scan :
000000000000000000000000000000000000000000000002b809677889fb1078 | Hash 160 20cb78b594b77cf97259be5cc414f0a49f1bde81 | 13zQNb5x4P7vCjag18rZKCVHkBcqtddaLS | 102.92 sec | 136.0 keys/sec |
00000000000000000000000000000000000000000000000285a7e79fd01fc2a4 | Hash 160 20cbc445f68147eb89314c6710de2a7c5fc2e0fb | 13zQj6btR6awFjac835xsvDqeCtVyioiiW | 112.67 sec | 124.9 keys/sec |
000000000000000000000000000000000000000000000002757de2916bb72c92 | Hash 160 20cbc889d5186984e2189dd818e67d990f992459 | 13zQkFk3v2WXrhLVVhP2NKM1JT4Gbd6VoY | 153.39 sec | 110.4 keys/sec |
000000000000000000000000000000000000000000000002a6bdd8aaca2a5a56 | Hash 160 20cbb6398c3a2a9ad13eec60d2ffd84ed113d96d | 13zQfHTEd9EZncjXmiKMoZV7SqSZP39myL | 159.93 sec | 100.8 keys/sec |


I'm very grateful the result seem make some chance to hit the targeted and correct key
000000000000000000000000000000000000000000000002b809677889fb1078 | Hash 160 20cb78b594b77cf97259be5cc414f0a49f1bde81 | 13zQNb5x4P7vCjag18rZKCVHkBcqtddaLS | 102.92 sec | 136.0 keys/sec |

i make some checkpoint rules and check if at least 10 addresses have similarity in hash160 derived from private key.

It seems like you are doing a search for a partial address/h160 collision? Is this true?

If so, there are GPU tools out there, that do billions of keys per second.

Not to discourage you from further developing your script, but you should be getting a lot more than 100 - 136 keys per second, even with python. I can help you speed it up, but again, you will need luck.

Also, to what citb0in said, there is no correlation between partial matches of addresses/h160. Or at least no one has found one yet.

sure! that's true, i do partial address/h160 collision, it's like SOLO Mining LOL, need 99%luck.

btw,i make improvements here's before i send the codes to you, take a look puzzle 160 bit

Target 160 bit :
1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv
e84818e1bf7f699aa6e28ef9edfb582099099292

000000000000000000000000bd09c95a35d1f621cfa61ea176f233ea43372317 | Hash 160 e8486774faf19368fb70016092c5258f053b8969 | 1NBCWESVYkRh6kxxuK5hP5pH8jJkWsXkTv | 711.83 sec |

Similiarities Address :

1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv
1NBCWESVYkRh6kxxuK5hP5pH8jJkWsXkTv

Similiarities hash 160 :
e84818e1bf7f699aa6e28ef9edfb582099099292
e8486774faf19368fb70016092c5258f053b8969

it's unique, if i do perform scan range bit '1-'4 it's difficult, if i do 4'0, 4'5, 5'0, 5'5, the puzzle took 4-6 hours to complete with my codes, if want use for larger bits, need math for settings the collision :

                if counter >= 2:
                    # Check if at least addresses have similarity in hash160
                    similarity_count = sum(a == b for a, b in zip(public_key_hash.hex()[:8], target_hash[:8]))
                    if similarity_count >= 7:
                        # At least addresses have similarity, determine bit size of target hash
                        bit_size = len(target_hash) * 4  # Multiply by 4 to convert bytes to bits

                        if bit_size < 160:
                            # Increase search range for smaller bit sizes
                            start_range += 3690000
                            end_range += 3690000
                        else:
                            # Decrease search range for larger bit sizes
                            start_range = max(0, start_range - 100000000 )
                            end_range = max(0, end_range - 100000000)
17  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: February 06, 2024, 06:08:32 AM
what do you mean bro ?
18  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: February 06, 2024, 03:01:07 AM
But how do devs calculate their speed when using BSGS?

I see a lot of peta, exa keys per second, I’m trying to figure out how they calculate the speed…and then apply it to my script.

Well, if you were the person you claim to be (WanderingPhilosopher Keyhunt), you probably wouldn't had put this question.

The source code of Keyhunt is open and you can see how the speed is determined. It is in the nature of the BSGS algorithm that you cannot compare these values with the classic searches. The same applies to Kangaroo, which is a completely different approach. A comparison would be like comparing apples and oranges. These are completely different algorithms, for example: if you run Kangaroo well-tuned and you would rely on the speed rate the tool shows you and then compare it to the speed of let's say BSGS you would be disappointed. Because BSGS will report a much higher rate. But in fact, the  Kangaroo will always run faster than BSGS. Again, you cannot compare them.

In BSGS mode of keyhunt for example the speed shown also depends on the pubkeys used. More keys will result in less speed.

Honestly, it’s a simple question, maybe you shouldn’t try to answer.

I’m not trying to compare potatoes and cabbage.

If I am using BSGS and can find a 52 bit key in 30 seconds, what’s the speed? 😂

It really wasn't meant to spurn any controversy. I know others have disagreed in the past, so I was curious to what people had to say.

If I use albertobsd method, I can say that the speed of my single core python script gets roughly, 140,549,854,653,356  Keys/s.
I wasn't trying to say it was fast or anything, just curious as to the actual speed and how different people view it.
I've been working on a low memory BSGS script; this one only uses about 500MB of RAM. Low memory, for various reasons but my reason is because I wrote a server/client script (python) and some of my machines have 8-16 GB max on them so I needed a way to employ them via low memory.



Quote
my search rate per hour for 30 bit above is approximately 800,324 keys per hours (like what i said before about leaking the cpu speed and more usage ram when 30 bit above)

Time to find 66-bit key≈1.75×108years
Your code does seem on the slower side of speed, but I was just going to show you some ways/see if we could speed it up (using python only). Not saying it will ever solve a puzzle, but more speed never hurts.

hi sir, i'm very motivated with your opinion about search speed.

i do some Experiment, trial and error for 66 bit

Let's say i take one 66 bit address for practice
000000000000000000000000000000000000000000000002be7989dd1a1a63ad | Hash 160 20cb77af1a425c5e74483d9b30cf950911a090de | 13zQNJwpREZogcPSkNJmYQzZ9HZQZS48Hx [TARGET]

result scan :
000000000000000000000000000000000000000000000002b809677889fb1078 | Hash 160 20cb78b594b77cf97259be5cc414f0a49f1bde81 | 13zQNb5x4P7vCjag18rZKCVHkBcqtddaLS | 102.92 sec | 136.0 keys/sec |
00000000000000000000000000000000000000000000000285a7e79fd01fc2a4 | Hash 160 20cbc445f68147eb89314c6710de2a7c5fc2e0fb | 13zQj6btR6awFjac835xsvDqeCtVyioiiW | 112.67 sec | 124.9 keys/sec |
000000000000000000000000000000000000000000000002757de2916bb72c92 | Hash 160 20cbc889d5186984e2189dd818e67d990f992459 | 13zQkFk3v2WXrhLVVhP2NKM1JT4Gbd6VoY | 153.39 sec | 110.4 keys/sec |
000000000000000000000000000000000000000000000002a6bdd8aaca2a5a56 | Hash 160 20cbb6398c3a2a9ad13eec60d2ffd84ed113d96d | 13zQfHTEd9EZncjXmiKMoZV7SqSZP39myL | 159.93 sec | 100.8 keys/sec |


I'm very grateful the result seem make some chance to hit the targeted and correct key
000000000000000000000000000000000000000000000002b809677889fb1078 | Hash 160 20cb78b594b77cf97259be5cc414f0a49f1bde81 | 13zQNb5x4P7vCjag18rZKCVHkBcqtddaLS | 102.92 sec | 136.0 keys/sec |

i make some checkpoint rules and check if at least 10 addresses have similarity in hash160 derived from private key.
19  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: February 03, 2024, 09:58:52 PM
Also, question for everyone, if you can solve a 52 bit key, with known pubkey, in 30 seconds, what rate of speed is that?
Simplify the question, if you one is using some version of BSGS and finds a 52 bit key within 30 seconds, what's the speed?

When we talk mathematically about speed, it is calculated as the distance traveled divided by the time it takes to travel that distance (it only has magnitude). It can be defined also in terms of other quantities besides distance, depending on the context. In physics, speed is often defined as the rate of change of position over time, which is commonly expressed as distance traveled divided by the time taken to travel that distance, as mentioned earlier. In certain situations it can also be defined in terms of other quantities such as: angles, phases or displacements.

Your question can therefore not be answered because it is incomplete. Neither the first nor the second.

You could count the steps performed or keys tried and divide the total by the total time required. Then you would have keys/sec or steps/sec as the result, depends on your needs.
But you can't calculate 52bits/30sec and claim that you can work out 0.577 sec per number of bits, and of course you know yourself why that is. Because otherwise you would have already solved the entire puzzle hundreds of times  Grin Cheesy

But how do devs calculate their speed when using BSGS?

I see a lot of peta, exa keys per second, I’m trying to figure out how they calculate the speed…and then apply it to my script.



thank you, I will DM (message) for the source code, wait a minute because I want to add a few things about thread speed, because there is a little bug in the private key search process.
Btw .. this is a very wise answer, sorry I also didn't think to ask like that, I also confused about how the developer can calculate freely for the entire search period with different speeds for each device, and also a different load key search..
but once again.. thank you, this is a wise answer and can be understood more broadly.
repp+ WanderingPhilospher


my code was running build with this formula, to trial and error for setup 66 bit keys.

number of possible 66-bit keys divided with search rate from 30-bit key.

my search rate per hour for 30 bit above is approximately 800,324 keys per hours (like what i said before about leaking the cpu speed and more usage ram when 30 bit above)

Time to find 66-bit key≈1.75×108years

 


 

20  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: February 03, 2024, 05:21:12 PM
First things first --> stop the consecutive posts

apparently you missed developing a performance counter to measure your capabilities. Let me do the maths for you...

Searched 173862 keys in 40.74 seconds | Private key: 0000000000000000000000000000000000000000000000000000000374830ffc | Address (Compressed): 1Pwab9zMnNd5aeM2KZX8itAncLxUzcZNwn
173862 / 40.74 = 4,268 Keys/sec


Searched 1576434 keys in 343.24 seconds | Private key: 00000000000000000000000000000000000000000000000000000003e0bf05e1 | Address (Compressed): 1PWAAsuv2CfHs63zVixBxb39dYoMj7bR5G

1576434 / 343.24 = 4,593 Keys/sec

4,5 K/sec ... seriously?

the search is using secret formula to make the rate of search not far away from actual range.

I wouldn't make this secret elixir public under any circumstances, it would change the world. Please keep the secret to yourself

can someone rate this ?
done. Now go ahead and solve puzzle 66 using your magic elixir sir

Thank you for your input, I'm still a beginner and trying to develop it, I'm still trying and remain positive for the community Cheesy

and how about this sir ?
i tweak some vanity search of 23 bit puzzle with cpu speed and hash160 filter and private key downscale multiplications

Searched 645240 keys in 0.55 seconds | Private key: 000000000000000000000000000000000000000000000000000000000054df77 | Address (Compressed): 1L2gKhvbWubwppJLfZXAhSfLuG8xw3uL9X
Searched 666794 keys in 0.58 seconds | Private key: 000000000000000000000000000000000000000000000000000000000045e993 | Address (Compressed): 1L2gVKpCZAPwDSTMEo3diJeKNybKeo3RjR
Searched 849294 keys in 0.60 seconds | Private key: 00000000000000000000000000000000000000000000000000000000006ba875 | Address (Compressed): 1L2gwSaaRWnK7Xj8E9upXrwXS5M9BYqjwH
Searched 857465 keys in 1.16 seconds | Private key: 000000000000000000000000000000000000000000000000000000000042707b | Address (Compressed): 1L2gP2jnz4AEXGTfMwvhgytvPwUtGMUzGJ
Searched 861241 keys in 1.88 seconds | Private key: 000000000000000000000000000000000000000000000000000000000056484a | Address (Compressed): 1L2GnHVKQ5AQZw5FASVy4USoRrUteR6Qpz
Searched 897078 keys in 2.73 seconds | Private key: 00000000000000000000000000000000000000000000000000000000004af06e | Address (Compressed): 1L2g5efN8kWG2fwEd2QUFLTNfnc96hBXqc
Searched 920717 keys in 3.26 seconds | Private key: 0000000000000000000000000000000000000000000000000000000000556e52 | Address (Compressed): 1L2GM8eE7mJWLdo3HZS6su1832NX2txaac
Found matching address (Compressed): 1L2GM8eE7mJWLdo3HZS6su1832NX2txaac | Private key: 0000000000000000000000000000000000000000000000000000000000556e52

The downside is that if I run 30 bit and above, it takes up a lot of RAM and CPU and also becomes unstable, resulting in a lot of decreases in the key search, and very drastically.

Pages: [1] 2 3 »
Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!