Testing Your Luck: Generating an Ethereum Wallet and Checking Its Balance

Testing Your Luck: Generating an Ethereum Wallet and Checking Its Balance

Have you ever wondered what it would be like to randomly generate an Ethereum wallet and check if it has any balance? Well, let’s be honest—it’s a near-impossible dream, but that doesn’t mean we can’t have some fun testing our luck!

In this blog post, we’ll explore a simple Python script that generates an Ethereum wallet and checks its balance. If you’re the luckiest person in the world, who knows? You might just stumble upon an old wallet with some forgotten ETH!

Setting Up Your Environment

Before running the script, ensure you have Python installed along with the required dependencies. You can install the necessary package using:

1
pip install eth_account --break-system-packages

This will install the eth_account package, which allows us to generate Ethereum wallets programmatically.

Bypassing Public Node Rate Limits

If you want to check balances at scale, relying on public Ethereum nodes isn’t practical since they often limit requests to 5-10 per second. You might consider running your own Ethereum node using services like Infura, Alchemy, or a self-hosted Geth node. This way, you can perform unlimited checks without hitting request limits. Check my lastest post for the tutorial to install Ethereum node. In this example, the IP of Ethereum node is: 192.168.1.150

The Ethereum Wallet Generator

Here’s a simple Python script that generates an Ethereum private key, derives the corresponding public address, and checks the balance:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
import requests
import json
import secrets
import threading
import time
from eth_account import Account

def generate_eth_account():
    """
    Generate a new Ethereum account with a private key.
    
    :return: Tuple (private_key, address)
    """
    private_key = "0x" + secrets.token_hex(32)
    account = Account.from_key(private_key)
    return private_key, account.address

def get_eth_balance(node_url, address):
    """
    Fetch the Ethereum balance of a given address from a JSON-RPC node.
    
    :param node_url: The URL of the Ethereum node (e.g., http://192.168.1.150:8080)
    :param address: The Ethereum address to query
    :return: Balance in Ether (float)
    """
    payload = {
        "jsonrpc": "2.0",
        "method": "eth_getBalance",
        "params": [address, "latest"],
        "id": 1
    }
    
    headers = {"Content-Type": "application/json"}
    
    try:
        response = requests.post(node_url, headers=headers, data=json.dumps(payload))
        response_data = response.json()
        
        if "result" in response_data:
            wei_balance = int(response_data["result"], 16)
            ether_balance = wei_balance / 1e18
            return ether_balance
        else:
            return 0.0
    except requests.exceptions.RequestException as e:
        return 0.0

global_counter = 0
good = 0
counter_lock = threading.Lock()
start_time = time.time()
num_threads = 300 # Adjust the number of threads as needed

def process_account(node_url):
    """
    Generate an Ethereum account, get its balance, and save results to files.
    Runs indefinitely.
    """
    global global_counter, num_threads, good, start_time
    while True:
        private_key, address = generate_eth_account()
        balance = get_eth_balance(node_url, address)
        
        log_entry = f"{address} {private_key} {balance}\n"
        
        with open("log.txt", "a") as log_file:
            log_file.write(log_entry)
        
        if balance != 0.0:
            with open("good.txt", "a") as good_file:
                good_file.write(log_entry)
                good += 1
        
        with counter_lock:
            global_counter += 1
            if global_counter % 1000 == 0:
                elapsed_time = time.time() - start_time
                print(f"{global_counter} checked | Runtime: {elapsed_time:.2f} seconds | Total {num_threads} threads | Total {good} good")
                start_time = time.time()

def main():
    node_url = "http://192.168.1.150:8080"

    
    threads = [threading.Thread(target=process_account, args=(node_url,), daemon=True) for _ in range(num_threads)]
    
    for thread in threads:
        thread.start()
    
    for thread in threads:
        thread.join()

if __name__ == "__main__":
    main()

Why Is This Fun but Unrealistic?

Ethereum addresses are derived from a 256-bit private key space, meaning there are 2^256 possible addresses. The chances of generating an address that already has ETH are astronomically small—essentially impossible. But hey, it’s still fun to dream, right?

Final Thoughts

Give it a shot and let me know if you hit the jackpot (spoiler: you won’t). 😆 Happy coding!