Bitcoin puzzle transaction ~32 BTC prize to who solves it

[dextronomous]

Nomachine where you at mate, you around or not?
missing his coding skills,
we all need a thing or two more to do around here, and its a bit silent in here,
so waiting wanting some of this good stuff, 

[pbies]

Nomachine where you at mate, you around or not?

Better is to say exactly what you need from the start, than to ping a guy which is busy.

[epomis]

I stumbled upon this: https://www.youtube.com/watch?v=35Euhs7bzGM

He claims to have found the deterministic nature of the puzzle seeds and to have solved 71.
Mastermind or possible scam attempt?

Might be Japanese (again!  ) looking at his script comments.

[SRG02289]

I stumbled upon this: https://www.youtube.com/watch?v=35Euhs7bzGM

He claims to have found the deterministic nature of the puzzle seeds and to have solved 71.
Mastermind or possible scam attempt?

Might be Japanese (again!  ) looking at his script comments.

The coins are all in place. It's a scam.

[BlackAKAAngel]

I stumbled upon this: https://www.youtube.com/watch?v=35Euhs7bzGM

He claims to have found the deterministic nature of the puzzle seeds and to have solved 71.
Mastermind or possible scam attempt?

Might be Japanese (again!   ) looking at his script comments.

The coins are all in place. It's a scam.

i dont think its japanese but here the code its not entire code >>>><

Code:

# -*- coding: utf-8 -*-
import sys
import time
import random
from sympy import symbols, sympify, SympifyError

TAKOU_SHIKI_JIZOKUSEI_SOU = "seeds.txt"
DOKURITSU_HENSUU_SHIKIBETSU_SHI = 'n'

#this is the rng the creator used. Lets run it.


def kakuritsuteki_kikan_no_shokika():
    print("計算環境を初期化しています...")
    tane = int(time.time() * 1000)
    random.seed(tane)
    shoki_joutai_bekutoru = random.getrandbits(32)
    print("...メルセンヌ・ツイスタの状態がシード {0} で水和されました。初期状態ベクトル: {1}".format(tane, shoki_joutai_bekutoru))
    print("...環境の準備ができました。")




def jizokusei_sou_kara_tayoutai_wo_fukugen(pasu):
    try:
        with open(pasu, "r", encoding="utf-8") as fuaido_kisojushi:
            nama_tayoutai_deeta = fuaido_kisojushi.read().strip()
            return nama_tayoutai_deeta
    except IOError as e:
        print("致命的: I/Oサブシステム障害。永続層から逆シリアル化できませんでした: {0}".format(e))
        return None
        
        
      #  <-----------------73 Lines REDACTED-------->





def kiseki_de_shiki_wo_hyouka(kigouteki_hyougen_tayoutai, dokuritsu_hensuu, hyouka_kiseki):
    return kigouteki_hyougen_tayoutai.subs(dokuritsu_hensuu, hyouka_kiseki)


def format_hex(val):
    i = int(val)
    h = format(i, 'x')  # convert to hex without prefix
    if len(h) < 64:
        h = h.rjust(64, '0')  # pad with leading zeros to 64 chars
    return h


def taiwa_gata_hyouka_purotokoru_kaishi(shiki_tayoutai, hensuu_kigou):
    print("\n--- 対話型評価プロトコル開始 ---")
    while True:
        try:
            nyuryoku_moji = input("シーケンスの位置を入力してください（終了するには0を入力）: ")
            ichi_kiseki = int(nyuryoku_moji)

            if ichi_kiseki == 0:
                print("終了信号を受信しました。対話プロトコルをシャットダウンします。")
                break

            tokubetsu_na_kekka = tokushu_jirei_no_kensa(ichi_kiseki)
            if tokubetsu_na_kekka is not None:
                kekka = tokubetsu_na_kekka
            else:
                kekka = kiseki_de_shiki_wo_hyouka(shiki_tayoutai, hensuu_kigou, ichi_kiseki)

            print(format_hex(kekka))

        except (ValueError, TypeError) as e:
            print("エラー: 無効な入力データです。整数の軌跡を指定してください。詳細: {0}".format(e))
        except Exception as e:
            print("予期せぬシステム例外が発生しました: {0}".format(e))


def shuyou():
    kakuritsuteki_kikan_no_shokika()

    takou_shiki_moji = jizokusei_sou_kara_tayoutai_wo_fukugen(TAKOU_SHIKI_JIZOKUSEI_SOU)
    if takou_shiki_moji is None:
        sys.exit(1)

    dokuritsu_hensuu_zeta = symbols(DOKURITSU_HENSUU_SHIKIBETSU_SHI)

    try:
        kigouteki_hyougen_tayoutai = sympify(takou_shiki_moji)
    except SympifyError as e:
        print("致命的: 多様体の解析に失敗しました。提供された式文字列の構文が無効です: {0}".format(e))
        sys.exit(1)

    if len(sys.argv) > 1:
        try:
            batchi_kiseki = int(sys.argv[1])
            print("\n--- バッチモード操作 ---")

            tokubetsu_na_kekka = tokushu_jirei_no_kensa(batchi_kiseki)
            if tokubetsu_na_kekka is not None:
                kekka = tokubetsu_na_kekka
            else:
                kekka = kiseki_de_shiki_wo_hyouka(kigouteki_hyougen_tayoutai, dokuritsu_hensuu_zeta, batchi_kiseki)

            print(format_hex(kekka))
        except ValueError:
            print("エラー: コマンドライン引数は有効な整数でなければなりません。")
    else:
        taiwa_gata_hyouka_purotokoru_kaishi(kigouteki_hyougen_tayoutai, dokuritsu_hensuu_zeta)


if __name__ == "__main__":
    shuyou()

>>>>>>english<<<<<<<<<
 

Code:

# -*- coding: utf-8 -*-
import sys
import time
import random
from sympy import symbols, sympify, SympifyError

PERSISTENT_FORMULA_SOU = "seeds.txt"
INDEPENDENT_VARIABLE_ID = 'n'

def probabilistic_machine_initialization():
    print("Initializing computational environment...")
    seed = int(time.time() * 1000)
    random.seed(seed)
    initial_state_vector = random.getrandbits(32)
    print("...Mersenne Twister state hydrated with seed {0}. Initial state vector: {1}".format(seed, initial_state_vector))
    print("...Environment ready.")

def restore_state_from_persistent_layer(path):
    try:
        with open(path, "r", encoding="utf-8") as file_base_substrate:
            raw_state_data = file_base_substrate.read().strip()
            return raw_state_data
    except IOError as e:
        print("Fatal: I/O subsystem failure. Could not deserialize from persistent layer: {0}".format(e))
        return None
        
# <-----------------73 Lines REDACTED-------->

def evaluate_expression_at_trajectory(symbolic_expression_state, independent_variable, evaluation_trajectory):
    return symbolic_expression_state.subs(independent_variable, evaluation_trajectory)

def format_hex(val):
    i = int(val)
    h = format(i, 'x')  # convert to hex without prefix
    if len(h) < 64:
        h = h.rjust(64, '0')  # pad with leading zeros to 64 chars
    return h

def interactive_evaluation_protocol_start(expression_state, variable_symbol):
    print("\n--- Interactive evaluation protocol started ---")
    while True:
        try:
            input_string = input("Enter sequence position (enter 0 to exit): ")
            trajectory_position = int(input_string)

            if trajectory_position == 0:
                print("Exit signal received. Shutting down interactive protocol.")
                break

            special_result = check_special_case(trajectory_position)
            if special_result is not None:
                result = special_result
            else:
                result = evaluate_expression_at_trajectory(expression_state, variable_symbol, trajectory_position)

            print(format_hex(result))

        except (ValueError, TypeError) as e:
            print("Error: Invalid input data. Please specify an integer trajectory. Details: {0}".format(e))
        except Exception as e:
            print("Unexpected system exception occurred: {0}".format(e))

def main():
    probabilistic_machine_initialization()

    formula_string = restore_state_from_persistent_layer(PERSISTENT_FORMULA_SOU)
    if formula_string is None:
        sys.exit(1)

    independent_variable_zeta = symbols(INDEPENDENT_VARIABLE_ID)

    try:
        symbolic_expression_state = sympify(formula_string)
    except SympifyError as e:
        print("Fatal: Failed to parse manifold. Invalid syntax in provided formula string: {0}".format(e))
        sys.exit(1)

    if len(sys.argv) > 1:
        try:
            batch_trajectory = int(sys.argv[1])
            print("\n--- Batch mode operation ---")

            special_result = check_special_case(batch_trajectory)
            if special_result is not None:
                result = special_result
            else:
                result = evaluate_expression_at_trajectory(symbolic_expression_state, independent_variable_zeta, batch_trajectory)

            print(format_hex(result))
        except ValueError:
            print("Error: Command line argument must be a valid integer.")
    else:
        interactive_evaluation_protocol_start(symbolic_expression_state, independent_variable_zeta)

if __name__ == "__main__":
    main()

[SRG02289]

It's much simpler. The code used to create the sequence was already published in this thread. You only need to specify the seed phrase.
I changed it a little.

Code:

import random
import hashlib
import base58
import ecdsa

for puzzle in range(1, 257):
      lower = 2 ** (puzzle - 1)
      upper = (2 ** puzzle) - 1
      seed = "SEED" + str(puzzle)
      random.seed(seed)
      dec = random.randint(lower, upper)
      
      """Convert a seed in hex and WIF format."""
      private_key_hex = "%064x" %  dec                       #HEX Private Key
      private_key_bytes = bytes.fromhex(private_key_hex)
      extended_key = b'\x80' + private_key_bytes
      extended_key += b'\x01'
      checksum = hashlib.sha256(hashlib.sha256(extended_key).digest()).digest()[:4]
      wif_bytes = extended_key + checksum
      wif_compressed = base58.b58encode(wif_bytes).decode()  #WIF Compressed Private Key
      
      """Convert a WIF in compressed Hash160."""
      sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
      vk = sk.get_verifying_key()
      public_key = vk.to_string("compressed")
      sha256_hash = hashlib.sha256(public_key).digest()
      ripemd160 = hashlib.new("ripemd160")
      ripemd160.update(sha256_hash)
      addressHash = ripemd160.hexdigest()    # HASH160 KEY
      
      """Convert a compressed Hash160 to Address format."""
      key_hash = '00' + addressHash   
      sha = hashlib.sha256()
      sha.update( bytearray.fromhex(key_hash) )
      checksum = sha.digest()
      sha = hashlib.sha256()
      sha.update(checksum)
      checksum = sha.hexdigest()[0:8]
      cAddr = base58.b58encode( bytes(bytearray.fromhex(key_hash + checksum) )).decode('utf-8')    #Compressed Address Key 
            
      print(f"{puzzle} Hex = {private_key_hex} Address = {cAddr}")
      
      """Save to file."""
      with open("output.txt", "a") as f:
          f.writelines(f" Seed = {seed} Hex = {private_key_hex} Address = {cAddr} Wif = {wif_compressed} \n")

[BlackAKAAngel]

It's much simpler. The code used to create the sequence was already published in this thread. You only need to specify the seed phrase.
I changed it a little.

Code:

import random
import hashlib
import base58
import ecdsa

for puzzle in range(1, 257):
      lower = 2 ** (puzzle - 1)
      upper = (2 ** puzzle) - 1
      seed = "SEED" + str(puzzle)
      random.seed(seed)
      dec = random.randint(lower, upper)
      
      """Convert a seed in hex and WIF format."""
      private_key_hex = "%064x" %  dec                       #HEX Private Key
      private_key_bytes = bytes.fromhex(private_key_hex)
      extended_key = b'\x80' + private_key_bytes
      extended_key += b'\x01'
      checksum = hashlib.sha256(hashlib.sha256(extended_key).digest()).digest()[:4]
      wif_bytes = extended_key + checksum
      wif_compressed = base58.b58encode(wif_bytes).decode()  #WIF Compressed Private Key
      
      """Convert a WIF in compressed Hash160."""
      sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
      vk = sk.get_verifying_key()
      public_key = vk.to_string("compressed")
      sha256_hash = hashlib.sha256(public_key).digest()
      ripemd160 = hashlib.new("ripemd160")
      ripemd160.update(sha256_hash)
      addressHash = ripemd160.hexdigest()    # HASH160 KEY
      
      """Convert a compressed Hash160 to Address format."""
      key_hash = '00' + addressHash   
      sha = hashlib.sha256()
      sha.update( bytearray.fromhex(key_hash) )
      checksum = sha.digest()
      sha = hashlib.sha256()
      sha.update(checksum)
      checksum = sha.hexdigest()[0:8]
      cAddr = base58.b58encode( bytes(bytearray.fromhex(key_hash + checksum) )).decode('utf-8')    #Compressed Address Key 
            
      print(f"{puzzle} Hex = {private_key_hex} Address = {cAddr}")
      
      """Save to file."""
      with open("output.txt", "a") as f:
          f.writelines(f" Seed = {seed} Hex = {private_key_hex} Address = {cAddr} Wif = {wif_compressed} \n")

these code are not mine i downloadet from thet japanese or china what ever its

[Menowa*]

I stumbled upon this: https://www.youtube.com/watch?v=35Euhs7bzGM

He claims to have found the deterministic nature of the puzzle seeds and to have solved 71.
Mastermind or possible scam attempt?

Might be Japanese (again!   ) looking at his script comments.

I saw the Thread on Reddit it's a full scam there is a malicious code in the program once you download it it injects your c:// file system and whenever you find a match of the target with any other software it will send it right away to the Creator of the program he got an idea which is falsely misleading everyone that he had found the solution of the puzzle! the coins are just in place and at current time and if I had a such code I wouldn't be sharing it with the public I would take all the coins for myself.

The moment the funds still remains there, no matter what someone says it’s prolly gonna be a lie. We’re supposed to doubt of everyone who claims that solved it or found a miraculous way to crack it, as we see until today: everybody who said that didn’t actually solved it. There’s no such a thing. Even if it was true no one would share. Sometimes people deserve what they’re going through for believing in shortcuts and dreams

[optioncmdPR]

I stumbled upon this: https://www.youtube.com/watch?v=35Euhs7bzGM

He claims to have found the deterministic nature of the puzzle seeds and to have solved 71.
Mastermind or possible scam attempt?

Might be Japanese (again!  ) looking at his script comments.

The coins are all in place. It's a scam.

If that was truly your wallet, the input addresses would already be known in stead of " unknown addresses ".
 Because you fake-imported the address without key,  you then  have to click the tools icon at top right for it to pull the address info from blockchain for you since it wasn't native to this wallet, which it surely would be if it was in your true localized history. In the end , you obviously just simply manually added the address of 71 as the  receiving address into your wallet text file. This will cause a corruption flag at start up but it will open and even look legit until its time to send due to invalid sig. That right there was all the info I personally needed to see this is complete BS before wasting any additional seconds of my life on entertaining your claim.
-Have a nice day! 

[Ali_555]

1PWo3JeB9TimEvu9PmogL7651vDAVJhmue 

6051dbadf7f49b1c5b

[kTimesG]

Unless some billionaire decides, just for fun, to waste a few million $, or BTC goes to 500k, we'll be talking about Puzzle 71 in 2029 as well.

[giorgi1919]

Hello, Bitcointalk community,

Link To Source Code https://github.com/georgetoloraia/intelligent-puzzle-solver

I have been fascinated by the cryptographic puzzles within our space and have developed an open-source, educational C++ project aimed at the 71-bit puzzle range (2^70 to 2^71). This is not a brute-force tool but an adaptive intelligence system that learns from its search attempts to optimize the process.

This solver implements a multi-threaded, self-optimizing search strategy. Instead of blind sequential scanning, it analyzes partial hash160 collisions to intelligently guide its search.

Core Concept: When a generated key produces a hash160 that matches the first N characters of the target, the system identifies the key's region as "promising" and focuses more computational power around it.

Self-Evolving Intelligence: The program dynamically adjusts its search threshold and resource allocation in real-time based on what it learns.

If anyone is interested, please help me improve, I love all ideas, even the smallest ones.

[Bram24732]

Hello, Bitcointalk community,

Link To Source Code https://github.com/georgetoloraia/intelligent-puzzle-solver

I have been fascinated by the cryptographic puzzles within our space and have developed an open-source, educational C++ project aimed at the 71-bit puzzle range (2^70 to 2^71). This is not a brute-force tool but an adaptive intelligence system that learns from its search attempts to optimize the process.

This solver implements a multi-threaded, self-optimizing search strategy. Instead of blind sequential scanning, it analyzes partial hash160 collisions to intelligently guide its search.

Core Concept: When a generated key produces a hash160 that matches the first N characters of the target, the system identifies the key's region as "promising" and focuses more computational power around it.

Self-Evolving Intelligence: The program dynamically adjusts its search threshold and resource allocation in real-time based on what it learns.

If anyone is interested, please help me improve, I love all ideas, even the smallest ones.

AI shit code, let’s bin it.

[giorgi1919]

Hello, Bitcointalk community,

Link To Source Code https://github.com/georgetoloraia/intelligent-puzzle-solver

I have been fascinated by the cryptographic puzzles within our space and have developed an open-source, educational C++ project aimed at the 71-bit puzzle range (2^70 to 2^71). This is not a brute-force tool but an adaptive intelligence system that learns from its search attempts to optimize the process.

This solver implements a multi-threaded, self-optimizing search strategy. Instead of blind sequential scanning, it analyzes partial hash160 collisions to intelligently guide its search.

Core Concept: When a generated key produces a hash160 that matches the first N characters of the target, the system identifies the key's region as "promising" and focuses more computational power around it.

Self-Evolving Intelligence: The program dynamically adjusts its search threshold and resource allocation in real-time based on what it learns.

If anyone is interested, please help me improve, I love all ideas, even the smallest ones.

AI shit code, let’s bin it.

[/quote]
Why throw it away, repurpose it
[/quote]

[kTimesG]

If anyone is interested, please help me improve, I love all ideas, even the smallest ones.

AI shit code, let’s bin it.

Why throw it away, repurpose it

My repurposed Bluetooth thermometer has more chances to find the key, than that GPT-based code running on a next-gen supercomputer.

[Virtuose]

Hello, Bitcointalk community,

Link To Source Code https://github.com/georgetoloraia/intelligent-puzzle-solver

I have been fascinated by the cryptographic puzzles within our space and have developed an open-source, educational C++ project aimed at the 71-bit puzzle range (2^70 to 2^71). This is not a brute-force tool but an adaptive intelligence system that learns from its search attempts to optimize the process.

This solver implements a multi-threaded, self-optimizing search strategy. Instead of blind sequential scanning, it analyzes partial hash160 collisions to intelligently guide its search.

Core Concept: When a generated key produces a hash160 that matches the first N characters of the target, the system identifies the key's region as "promising" and focuses more computational power around it.

Self-Evolving Intelligence: The program dynamically adjusts its search threshold and resource allocation in real-time based on what it learns.

If anyone is interested, please help me improve, I love all ideas, even the smallest ones.

Do you know that what you did is just a little basic pre-filtering before a search? 

[teguh54321]

I found 3 1PWo3JeB9j
Thats very near
Found three with same 5 leading hex.

Thats mean anything ? 😅

[Virtuose]

I found 3 1PWo3JeB9j
Thats very near
Found three with same 5 leading hex.

Thats mean anything ? 😅

No, that doesn't mean anything, it can be anywhere, there are probably billions of addresses that start with this..

[giorgi1919]

Hello, Bitcointalk community,

Link To Source Code https://github.com/georgetoloraia/intelligent-puzzle-solver

I have been fascinated by the cryptographic puzzles within our space and have developed an open-source, educational C++ project aimed at the 71-bit puzzle range (2^70 to 2^71). This is not a brute-force tool but an adaptive intelligence system that learns from its search attempts to optimize the process.

This solver implements a multi-threaded, self-optimizing search strategy. Instead of blind sequential scanning, it analyzes partial hash160 collisions to intelligently guide its search.

Core Concept: When a generated key produces a hash160 that matches the first N characters of the target, the system identifies the key's region as "promising" and focuses more computational power around it.

Self-Evolving Intelligence: The program dynamically adjusts its search threshold and resource allocation in real-time based on what it learns.

If anyone is interested, please help me improve, I love all ideas, even the smallest ones.

Do you know that what you did is just a little basic pre-filtering before a search? 

"Virtuose" -> You're right... I'll try to modify it... I wanted filtering while working, thanks.

[teguh54321]

I found 3 1PWo3JeB9j
Thats very near
Found three with same 5 leading hex.

Thats mean anything ? 😅

No, that doesn't mean anything, it can be anywhere, there are probably billions of addresses that start with this..

Currently i found
94 1PWo3JeB9j
1  1PWo3JeB9jr

Seems still far 😔 , majority at 7xxxx and 6xxxx😅

Here some✌️
1PWo3JeB9jWG3HZmrcLtrFD5NhYd9UKYgD 6074CA63DBBC4672E7
1PWo3JeB9jMFuZgfLp8V4w9kADUjEmDYzS 647494ED7003AA3FBF
1PWo3JeB9jF8toCrBPKwZZTkVeuUS1HpKr 7360CD4B5AEFB6C9EA
1PWo3JeB9jfwjqW7vCc9aNqnEbdPu9GUqS 5A8B7F7268C7E8462C
1PWo3JeB9jA9uQUhPRNN91rR8kgqF3p1cQ 6C70798D1A192D92E4