检验你是不是欧皇

这个工具会生成一个ETH私钥，然后生成公钥和地址。
接着在Ethplorer查询该地址有没有币。
因此在使用这个程序之前，需要搞一个Ethplorer的api，好在这个网站是有很高的免费额度的，虽然内地不好上。
这个程序的最大限制在于api的速度，如果是搞本地查询，那肯定飞快。
不管咋说，这东西都没啥用，2的32次方个钱包地址，找到有钱的，还没听说过（可能是我孤陋寡闻）。
如果你真的欧皇附体查到了，那理论上会出现在result.txt里面。
下面是这个程序的代码，记得改一下api。

import os
from eth_keys import keys
import requests
import time
import shelve
import logging
from collections import deque

api = "你的api"

# 设置日志记录
logging.basicConfig(filename="errorlog.log", level=logging.ERROR)

# 计数器存储文件
COUNTS_DB = "api_counts.db"

# 定义时间窗口长度
SECONDLY_TIME_FRAME = 1  # 每秒
HOURLY_TIME_FRAME = 3600  # 每小时
DAILY_TIME_FRAME = 86400  # 每天
WEEKLY_TIME_FRAME = 604800  # 每周

# 定义请求限制
LIMITS = {"second": 5, "hour": 17500, "day": 378000, "week": 2381400}


def get_counts():
    with shelve.open(COUNTS_DB) as db:
        if "timestamps" not in db:
            db["timestamps"] = deque(maxlen=SECONDLY_TIME_FRAME)
        return db["timestamps"]


def update_counts(timestamps):
    with shelve.open(COUNTS_DB, writeback=True) as db:
        db["timestamps"] = timestamps


def reset_counts():
    with shelve.open(COUNTS_DB, writeback=True) as db:
        db["timestamps"] = deque(maxlen=SECONDLY_TIME_FRAME)


def is_over_limit(timestamps, limit, time_frame):
    current_time = time.time()
    # 移除时间窗口之外的记录
    while timestamps and current_time - timestamps[0] > time_frame:
        timestamps.popleft()
    return len(timestamps) >= limit


def generate_key_pair():
    # 生成一个安全的随机私钥
    private_key = keys.PrivateKey(os.urandom(32))

    # 获取私钥的十六进制表示
    private_key_hex = private_key.to_hex()

    # 输出私钥
    # print(f"Private Key: {private_key_hex}")

    # 从私钥派生公钥
    public_key = private_key.public_key

    # 获取公钥的压缩形式
    public_key_compressed_hex = public_key.to_hex()

    # 输出公钥
    # print(f"Public Key: {public_key_compressed_hex}")

    # 生成以太坊地址
    address = public_key.to_checksum_address()

    # 输出地址
    # print(f"Ethereum Address: {address}")

    return private_key_hex, public_key_compressed_hex, address


def make_api_request(address):

    if not address:
        private_key_hex, public_key_compressed_hex, address = generate_key_pair()

    # 拼接请求
    url = f"https://api.ethplorer.io/getAddressInfo/" + address + "?apiKey=" + api

    # 发送请求
    response = requests.get(url)
    # 解析响应
    data = response.json()

    # 是否是空钱包
    non_zero_balances = False

    # 检测有没有ETH
    if data["ETH"]["balance"] != 0:
        non_zero_balances = True

    # 检测别的代币
    if "tokens" in data:
        for token in data["tokens"]:
            if token["balance"] != 0:
                non_zero_balances = True
                break
    # BNB链查询
    url = f"https://api.binplorer.com/getAddressInfo/" + address + "?apiKey=" + api

    # 发送请求
    response = requests.get(url)
    # 解析响应
    data = response.json()

    # 检测BNB（返回为ETH）
    if data["ETH"]["balance"] != 0:
        non_zero_balances = True

    # 检测别的代币
    if "tokens" in data:
        for token in data["tokens"]:
            if token["balance"] != 0:
                non_zero_balances = True
                break

    return non_zero_balances


def main():
    private_key_hex, public_key_compressed_hex, address = generate_key_pair()
    flag = True
    while True:
        timestamps = get_counts()

        # 检查是否超过限制
        if is_over_limit(timestamps, LIMITS["second"], SECONDLY_TIME_FRAME):
            time.sleep(0.1)  # 等待一段时间
            continue
        if is_over_limit(timestamps, LIMITS["hour"], HOURLY_TIME_FRAME):
            time.sleep(1)  # 等待一段时间
            continue
        if is_over_limit(timestamps, LIMITS["day"], DAILY_TIME_FRAME):
            time.sleep(10)  # 等待一段时间
            continue
        if is_over_limit(timestamps, LIMITS["week"], WEEKLY_TIME_FRAME):
            time.sleep(60)  # 等待一段时间
            continue

        try:
            non_zero_balances = make_api_request(address)
            timestamps.append(time.time())
            update_counts(timestamps)
        except Exception as e:
            logging.error(str(e))
            flag = False
        # Output message if any non-zero balance is found
        output_message = f"地址：{address}"
        output_message += f"\n私钥：{private_key_hex}"
        output_message += f"\n公钥：{public_key_compressed_hex}"
        print(output_message)
        if non_zero_balances:
            with open("result.txt", "a") as f:
                f.write(output_message + "\n")
        if flag:
            private_key_hex, public_key_compressed_hex, address = generate_key_pair()
        flag = True

        # 等待以限制每秒的请求次数
        time.sleep(0.1)  # 根据API请求的耗时调整这个值


if __name__ == "__main__":
    main()