Pretty TON Wallet generator

[15]

Change TARGET_STRING for your desired.

`pip install tonutils` or `uv add tonutils`
 

Code:

import sys
import signal
import multiprocessing
import time
from tonutils.client import ToncenterV3Client
from tonutils.wallet import WalletV5R1
import string


TARGET_STRING = "sync"
penis = [*string.ascii_lowercase, *string.digits]

# Counter to track executions
execution_count = multiprocessing.Value("i", 0)

pending_count = multiprocessing.Value("i", 0)

client = ToncenterV3Client(
    api_key="APIKEYFROM toncenter.com OR NOTHING",
    is_testnet=False,
    rps=10,
    max_retries=1,
)


def init_worker():
    # Ignore Ctrl+C in worker processes
    signal.signal(signal.SIGINT, signal.SIG_IGN)


def main() -> None:
    pool = multiprocessing.Pool(
        processes=multiprocessing.cpu_count(), initializer=init_worker
    )

    start_time = time.time()
    update_number = 0

    # Handle graceful shutdown
    def signal_handler(*_):
        print(
            f"\nStopping... Executed {execution_count.value} tasks in {time.time() - start_time:.2f} seconds"
        )
        pool.terminate()
        pool.join()
        sys.exit(0)

    signal.signal(signal.SIGINT, signal_handler)

    try:
        while True:
            with pending_count.get_lock():
                pending_count.value += 1

            if pending_count.value - execution_count.value > 25000:
                time.sleep(3)

            pool.apply_async(update, args=(update_number,))
            update_number += 1
            time.sleep(0.0001)
    except KeyboardInterrupt:
        # Handle case where signal_handler doesn't catch in time
        print(
            f"\nCaught KeyboardInterrupt. Executed {execution_count.value} tasks in {time.time() - start_time:.2f} seconds"
        )
        pool.terminate()
        pool.join()


def update(update_number: int = 0):
    address, mnemonic = generate_wallet()
    lower_address = address.lower()

    if TARGET_STRING in lower_address:
        print(f"Found target {TARGET_STRING} in", address, mnemonic)

    sim_calc_and_print(
        word=lower_address[len(TARGET_STRING) * -1 :],
        update_number=update_number,
        address=address,
        mnemonic=mnemonic,
        left_side=False,
    )

    sim_calc_and_print(
        word=lower_address[: len(TARGET_STRING)],
        update_number=update_number,
        address=address,
        mnemonic=mnemonic,
        left_side=True,
    )

    for letter in penis:
        if (letter * 5) in lower_address:
            print("5+ shit", address, mnemonic)

    with execution_count.get_lock():
        execution_count.value += 1


def sim_calc_and_print(
    word: str,
    update_number: int,
    address: str,
    mnemonic: list[str],
    left_side: bool = True,
):
    sim_count = sim_calc(word)
    if sim_count >= 4:
        print(
            f"\nFound sim_count {sim_count}>=4 {update_number} | {left_side=}, address = {address}"
        )
        print("Mnemonic", mnemonic, "\n")


def sim_calc(word: str) -> int:
    sim_count = 0
    for i, char in enumerate(word):
        if TARGET_STRING[i] == char:
            sim_count += 1

    return sim_count


def generate_wallet():
    wallet, _, _, mnemonic = WalletV5R1.create(client)
    return wallet.address.to_str(), mnemonic


if __name__ == "__main__":
    main()

[4.155]

I'll try this, yeah