Topic: Bitcoin; Algoritma Üzerine Yöntemler (Read 33723 times)

şunu da belirteyim. kodlarda 2^67 diye bir şey yok.

yazmayayım diyorum da hocam. bana internetten araştırıp araştırıp cevap vermeyin. 

Aşama-1 :
48 milyar deneme demek 48.000.000.000 yani = 48 x 10^9  bu sayıya da 4.8 x 10^10 olarak aldık.

Aşama- 2:
2^67 sayısı da  =147.573.952.589.676.412.928 bu sayıyı da  1.475×10^20

Aşama-3:
 1.475×10^20   /   4.8 x 10^10  = 3.072×10^9  bu sayıyı da genişletelim 3.072.000.000 sayısını buluruz.
(bu bulduğumuz sayı bizim 2^67'nin, saniyede 48 milyar denemede geçecek zamanı. saniye cinsinden değerimiz)

Aşama-4:
Bir yılda 31.556.926 saniye var toplamda.  3.072.000.000 / 31.556.926 yaptığımızda  = 97,347

Sonuç:
Yani 97 yıl.
Hangi mantıkla 48 yıl diyorsunuz. Her okuduğunuza inanmayın. Bakın buraya kadar ki kısmı genel bilgiydi. Şimdiki yazacaklarımda işin püf noktası.

Bitcoinin private key'i oluşturulurken;  2^256 −2^32 −977 ile alınır. daha buna versiyon baytı, sıkıştırma baytını ekleyeceğiz.
sonra sha256 ekleyeceğiz doğrulma, buna da  checksum diyelim.
private key = privatekey + checksum(sha256) (bu kısım kodlarda yok.)
Privatete keyimizi de dönüştürüyoruz  =privatekey(Base58)

örnekte ki kod da .import base58 kütüphanesi ve import ecdsa olduğu için ham private arıyoruz.
    sk = ecdsa.SigningKey.from_string(private_key, curve=ecdsa.SECP256k1)
kodunda da public key satırlarınız. neyse uzatmıyorum.

ilk başta söylediğimi tekrar söylüyorum. bu kolar bir işe yaramaz. sadece boşa zaman geçirmektir. eğiticimi evet çok eğitici. ama işe yararmı hayır. tekrar ediyorum. işe yaramaz.

hashlerle ilgili benim şu videomuda izleyebilirsiniz
https://www.youtube.com/watch?v=2kjvaOGZwtc&t=1087s

saygılar


 

Saniyede 48 milyar deneme yapan bir program, 67. bulmaca için doğru anahtarı 48 yılda bulabiliyor. Bu süre, belirlenen aralığı sıralı olarak denediğinde geçerli. Ancak random deneme yapmanın amacı, belirlenen aralıktaki private key'leri sürekli olarak saniyede 48 milyar deneme ile taramak. Bu yöntem, sıralı denemeye göre biraz daha mantıklı çünkü rastgele denemeler, sıralı denemeye kıyasla daha fazla şans sunuyor.

Bir üstte yazmış olduğum gibi, 130, 125, 120, 110 ve 1-66 arası bulmacalar daha önce çözüldü. Burada kimse sıralı olarak denemedi. Eğer sıralı olarak denemiş olsalardı, dediğiniz çok doğru olurdu. Ancak brute-force kullanarak random anahtar üretme yöntemi, sıralı sisteme göre daha fazla şans yakalanmasını sağlıyor.
Sizin hesaplamalarınızda ve son yazdıklarınızda bir sorun yok zaten.

Konu bildirimi açanlar için gereksiz mesajlar olacak, o nedenle ben de son kez yazayım istedim.

Hocam sen yanlış anladın. Şöyle anlatayım. Bu da bu başlıktaki son yazım olsun. Saniyede 48 milyar deneme dediniz. Gelin onu yuvarlayalım. 50 milyar diyelim. 2⁶⁷ için yaklaşık 100 yıla ihtiyacınız var. 2⁶⁸ derseniz bu zaman 200 yıla çıkar. 2⁶⁹ da 400 yıl olur. Rahat anlaşılsın diye yuvarlıyorum zamanları. Aşağı yukarı bu sayıları bulursunuz.

2⁶⁷-2²⁵⁶ yaparsanız. 189 katsayısını bulursunuz. Yani 100 yıl süren zamanı 189 kere 2 ile çarpın. 2¹⁸⁹ kat daha var key için.

Dediğim gibi eğitim amaçlı olabilir bu kodlar ama normalde hiçbir işe yaramaz.

Saygılar.

Bir üstte yazmış olduğunuz mesajda, 2^256 değerinin çok fazla olduğunu belirttiniz. Ancak ben size 2^256 değil, 2^67 olduğunu yazdım. Siz ise aynı şeyi tekrar ediyormuş gibi davranarak kendi yazdığınız mesajı düzeltmeye çalışıyorsunuz. 2^256 ile 2^67 aynı şey mi? Sonuç olarak, 2^130 değerindeki bir bulmaca bile çözüldü. Hatta 2^100 seviyelerinden çözülen birkaç tane daha bulmaca var. Söyledikleriniz ve hesaplamalarınız doğru, ancak 2^256'ye kıyasla 2^67 veya 2^68 gibi bulmacalarla uğraşmak çok daha mantıklı.

Hesaplama konusuna gelirsek:

1x RTX 3090: Saniyede 2 milyar deneme (2,000 MKeys/s).

1x RTX 4090: Saniyede 4 milyar deneme (4,000 MKeys/s).

12x RTX 4090: Saniyede 48 milyar deneme (48,000 MKeys/s) gibi ortalama bir değer düşünebiliriz.

Bu arada, bu işle uğraşan kişilere Linux veya Windows üzerinden Keyhunt kullanmalarını önerebilirim. Python scriptlerine göre daha hızlı sonuçlar alabilirsiniz.

Sisteminizin çok sağlam olması, bulma şansınızı doğrudan artırmaz. Sadece daha fazla deneme yapabildiğiniz için şansınız diğerlerine göre daha yüksek olur. Saniyede 10 bin cüzdan arayan bir sistem ile saniyede 48 milyar cüzdan üreten bir sistemin şansı elbette aynı değildir. Bunu, bir piyango çekilişinde 1 bilet alan biri ile 1000 bilet alan birinin durumuna benzetebilirsiniz. Yoksa, saniyede 10 bin cüzdan üreten bir kişi, 1 gecede, 1 ayda veya 1 senede bulabileceği gibi, hiç bulamayabilir de. Bu tamamen rastgele çalışan sistemde üretilen özel anahtarlar ile alakalıdır.

bende aynı şeyi söylüyorum işte
2^67  ×0.001 saniye  olarak düşünelim. o zaman bize lazım olan zaman =  1.472×10^17 saniye oluyor. bir yılda da toplam 31.536.000 saniye var. Bu değerini yıla böldüğün zaman 4.66×10^9 yıl yapar. Tahmini 5 Milyar yıl gibi bir sürer. Bak bu 2^67 deki deneme süren (0,001 saniyede bir deneme yaptığını düşünerek hesaplıyorum sende daha üstün cihaz varsa ona göre çıkar hesabını)
2^67 ile 2^256 arasında ki farkı hesaba kattığında evrenin oluşumuda kurtarmıyor. Eğlence amaçlı bir program yazmış arkadaşın biri. bir işe yarar mı yaramaz. ama eğitici olabilir. en azından mantığı görürler. saygılar

 

2^256 tüm olasılık. bulmacalarda belirli aralığı aradığınız için tamamını kapsamıyor. 67. bulmaca için 2^67

#67 puzzle's keyspace (from 2^66 till 2^67-1 decimal, 0x4 0000 0000 0000 0000 - 0x7 FFFF FFFF FFFF FFFF)

2^256 değeri:
115792089237316195423570985008687907853269984665640564039457584007913129639936

2^67 değeri:
73786976294838207


Kaynak :https://hashkeys.space/67/

kod bir işe yaramaz gibi duruyor. sağlam bir işlemciyle tahmini saniyede 300k anahtar denemesi yapabilirsin diyelim. ama aradığın anahtar 2 üzeri 256. yani kısaca şöyle söyleyeyim. evren ilk oluştuğunda bu programı çalıştırsaydın. bir ihtimal bulma şansın yüzde %1 falan olurdu.

Hocam, iki satır kod yeterli:
Bulmaca 67:

import secp256k1 as ice
import random

while(True):
    xx=random.randint(0x40000000000000000,0x7ffffffffffffffff)
    addrc= ice.privatekey_to_address(0, True, xx)
    if addrc== "1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9":
        dosya = open("XXXX.txt", "a")
        dosya.write(str(xx) + " " + addrc)
        dosya.close()
    else:
        if addrc0.startswith("1BY8GQ"):
          print(str(xx) + " "  + addrc)

Merhaba, ben zamanında bir matematik bilmecesi çözerek bitcoin programcısı Jimmy Song'un "Programming Bitcoin" kursunu bedavaya alma şansına eriştim ve kursta öğrendiklerimi uygulamak için -ve aynı zamanda eğlencesine- bu legacy adreslerden bitcoin aramanıza olanak sağlayan bir site yaptım. Oynamak için bakmak isteyebilirsiniz.
www.findfreebitcoin.com

Eğer 666 veya ilk 10 sayıyı denerseniz insanların gerçekten bu sayı ile türetilen legacy adreslere az da olsa bitcoin gönderdiklerini göreceksiniz 

Bulmacalar için bir kod bu işle uğraşanlar veya bilgisayar 7/24 açık olanlar deneyebilir
bulmacalardaki aralığı girin başlangıç ve bitiş private keyi
aranan adresi girin ve bırakın tarasın bulursa text dosyasına yazdırır, çözülen bulmacalarda deneyebilirsiniz MODÜLLERİ YÜKLEMEYİ UNUTMAYIN!

import hashlib
import ecdsa
import random
import base58
import tkinter as tk
from tkinter import messagebox
from threading import Thread

def private_key_to_compressed_public_key(private_key):
    sk = ecdsa.SigningKey.from_string(private_key, curve=ecdsa.SECP256k1)
    vk = sk.get_verifying_key()
    return (b'\x02' if vk.pubkey.point.y() % 2 == 0 else b'\x03') + vk.to_string()[:32]

def public_key_to_address(public_key):
    sha256_bpk = hashlib.sha256(public_key).digest()
    ripemd160_bpk = hashlib.new('ripemd160', sha256_bpk).digest()
    prefixed_ripemd160_bpk = b'\x00' + ripemd160_bpk
    sha256_1 = hashlib.sha256(prefixed_ripemd160_bpk).digest()
    sha256_2 = hashlib.sha256(sha256_1).digest()
    checksum = sha256_2[:4]
    binary_address = prefixed_ripemd160_bpk + checksum
    address = base58.b58encode(binary_address)
    return address.decode('utf-8')

def generate_random_private_key(start, end):
    return random.randint(start, end).to_bytes(32, byteorder='big')

def search_for_matching_key(target_address, start, end, status_label):
    scanned_keys = 0
    while True:
        private_key = generate_random_private_key(start, end)
        
      
        compressed_pubkey = private_key_to_compressed_public_key(private_key)
        compressed_address = public_key_to_address(compressed_pubkey)
        
        scanned_keys += 1
        status_label.config(text=f"Tarama yapılan private key sayısı: {scanned_keys}")
        root.update_idletasks()
        
        if compressed_address == target_address:
            with open("found_key.txt", "w") as file:
                file.write(f"Matching private key: {private_key.hex()}\n")
            return private_key.hex(), scanned_keys

def start_search():
    target_address = entry_address.get()
    start_range = int(entry_start.get(), 16)
    end_range = int(entry_end.get(), 16)
    
    if len(target_address) == 34 and start_range < end_range:
        status_label.config(text="Arama başlatılıyor...")
        root.update_idletasks()
        # İş parçacığı oluştur
        search_thread = Thread(target=search_key_in_background, args=(target_address, start_range, end_range))
        search_thread.start()
    else:
        messagebox.showerror("Hata", "Geçersiz girişler. Adresi ve private key aralığını kontrol edin.")

def search_key_in_background(target_address, start_range, end_range):
    try:
        matching_key, scanned_keys = search_for_matching_key(target_address, start_range, end_range, status_label)
        if matching_key:
            messagebox.showinfo("Sonuç", f"Eşleşen private key: {matching_key}\nTarama yapılan private key sayısı: {scanned_keys}")
        else:
            messagebox.showwarning("Sonuç", "Eşleşen private key bulunamadı.")
    except Exception as e:
        messagebox.showerror("Hata", f"Bir hata oluştu: {e}")

root = tk.Tk()
root.title("Bitcoin Private Key Bulucu")

tk.Label(root, text="Bitcoin Adresi:").grid(row=0, column=0)
entry_address = tk.Entry(root, width=50)
entry_address.grid(row=0, column=1)

tk.Label(root, text="Başlangıç Private Key (Hex):").grid(row=1, column=0)
entry_start = tk.Entry(root, width=50)
entry_start.grid(row=1, column=1)

tk.Label(root, text="Bitiş Private Key (Hex):").grid(row=2, column=0)
entry_end = tk.Entry(root, width=50)
entry_end.grid(row=2, column=1)

status_label = tk.Label(root, text="Tarama yapılacak...")
status_label.grid(row=4, column=0, columnspan=2)

search_button = tk.Button(root, text="Aramayı Başlat", command=start_search)
search_button.grid(row=3, column=0, columnspan=2)

root.mainloop()

Yıllardır takip edip, esince kurcaladığımız ve sıkılınca bırakıp bir daha kurcaladığımız bir bulmaca
 
https://bitcointalk.org/index.php?topic=1306983.0;topicseen


Eyvallah müdür.

 ..Sıkma canını be, ben senin problemini çözerim.

https://youtu.be/c7pN5imZWw0?t=52

Bu ne demek hocam anlayamadım.

66 nolu bulmaca da çözüldü moralim sıfır sıfır sıfır...

mhancım valla bende tam öyle düşünüyorum . vanity baya süredir GPU  destekli zaten. 12 ve daha fazla GPU lu clusterlar ile işlem baya hızlanıyor.

Günümüz GPU ları da  boru değil hani artık . 

Bazı arkadaşlar indregandi yapıyor bence sesi çıkmıyor     Hatta bir listede baya eskiden beri hareketsiz duran BTC lerin hareket edip cüzdanın sıfırlandığını görmüştüm.

Yapay zeka da ibne kendi yapıyordur, bize yapma başaramazsın der tabi. Öküz gibi process gücü var ondada.    Yap lan  belki olur  demez kesin bize.

Ama bence birçok adres üretip sorgulatmak yerine bence hedef tek 1 adrese odaklanıp onu vanity yapmak daha mantıklı gibi geliyor.  En azından SQL  mesqüel , sorgu işlerine kaynak ayrılmaz.

Yinede böyle güzel sağlam Db olan arkadaş varsa atsın link yahu.  BigDump falan yapar yardırırız, kendinize müslüman olmayın olum paylaşın, forum bura 

Sanılanın aksine bu konuda başarılı sonuçlar alan ve bunu paylaşmayan kişiler olduğunu düşünüyorum.
Bunu düşünmemin bir kaç sebebi var.

1. vanitygen ilk başlarda sadece cpu ile çalışıyordu artık gpu ile çalışan versiyonları da var.
2. çok sistematik bir şekilde 10 larca gpu ile paralel olarak adres üretip bunu bir tam düğümde sorgulamaya başladılar.
3. ürettikleri adres ve private keyleri önce mysql de sonra yetersiz kalınca postgresql da sakladıklarını okuduk.
4. hem sürekli adres üretmeye devam ediyorlar hemde daha önce ürettikleri adreslerinde bakiyelerini de belli aralıklar kontrol ediyorlar.

Buna rağmen yapay zeka boşuna uğraşıyorsunuz diyor.
https://bitcointalk.org/index.php?topic=5503710.new#new

İki kod daha uğraşan arkadaşlara

1. Kod BNB ağındaki sizin tarafınızdan verilen blok aralığındaki blokları tarayarak bakiyesi 0 dan büyük adresleri bir txt dosyasına yazdırır. (Api kullanmadığı için biraz zorlayabilir bazı bloklarda çok fazla adres olmasından kaynaklı)

2. Kod 1. kodda üretilen txt dosyasını hafızaya alıp rasgele private key üretip txt dosyasında bir eşleşmeyle karşılaşırsa başka bir txt dosyasına eşleşen adres ile pk yazdırır....


1. KOD >>>>>>

from web3 import Web3
from web3.middleware import geth_poa_middleware

bsc = Web3(Web3.HTTPProvider('https://bsc-dataseed.binance.org/'))
bsc.middleware_onion.inject(geth_poa_middleware, layer=0)

def check_balance(address):
    balance = bsc.eth.get_balance(address)
    return balance

def get_non_zero_balance_addresses(start_block, end_block):
    non_zero_addresses = set()
    
    for block_num in range(start_block, end_block + 1):
        block = bsc.eth.get_block(block_num, full_transactions=True)
        for tx in block.transactions:
            if tx.to:
                balance = check_balance(tx.to)
                if balance > 0:
                    non_zero_addresses.add((tx.to, Web3.from_wei(balance, 'ether')))
            
            balance = check_balance(tx['from'])
            if balance > 0:
                non_zero_addresses.add((tx['from'], Web3.from_wei(balance, 'ether')))
        
        print(f"Processed block {block_num}/{end_block}")
    
    return non_zero_addresses

def save_to_file(non_zero_addresses, filename='non_zero_balances.txt'):
    with open(filename, 'w') as f:
        for address, balance in non_zero_addresses:
            f.write(f'{address}\n')

def main():
    start_block = 1  # Başlangıç bloğunu belirleyin
    end_block = 3500  # Bitiş bloğunu belirleyin
    non_zero_addresses = get_non_zero_balance_addresses(start_block, end_block)
    save_to_file(non_zero_addresses)
    print(f'{len(non_zero_addresses)} addresses with non-zero balance found and saved to non_zero_balances.txt.')

if __name__ == '__main__':
    main()

2. KOD >>>>

import os
import random
import time
from web3 import Web3
from eth_account import Account

bsc = Web3(Web3.HTTPProvider('https://bsc-dataseed.binance.org/'))

def generate_random_keypair():
    account = Account.create(os.urandom(32))
    return account.key, account.address

def load_addresses(filename='non_zero_balances.txt'):
    addresses = set()
    with open(filename, 'r') as f:
        for line in f:
            if line.startswith('Address:'):
                address = line.split()[1][:-1]
                addresses.add(address)
    return addresses

def save_found_key(address, private_key, filename='found_keys.txt'):
    with open(filename, 'a') as f:
        f.write(f'Address: {address}, Private Key: {private_key}\n')

def main():
    known_addresses = load_addresses()
    print(f'Loaded {len(known_addresses)} known addresses.')

    found = False
    total_attempts = 0
    interval_attempts = 0
    start_time = time.time()

    while not found:
        private_key, address = generate_random_keypair()
        if address in known_addresses:
            print(f'Found a match! Address: {address}, Private Key: {private_key.hex()}')
            save_found_key(address, private_key.hex())
            found = True
        total_attempts += 1
        interval_attempts += 1

        current_time = time.time()
        if current_time - start_time >= 1:
            print(f'{interval_attempts} attempts made in the last second.')
            interval_attempts = 0
            start_time = current_time

        if total_attempts % 1000 == 0:
            print(f'{total_attempts} total attempts made, still searching...')

if __name__ == '__main__':
    main()

aşadaki kodda aynı anda 3 ağda (Eth, Bnb, Matic) kontrol etmenizi sağlar. Bu sefer sizden Private Keyinizi ister önce onun bakiyesini kontrol eder DENEME AMAÇLI ve arayüzlü exe haline getirmedim ki açık kaynak kodlu olsun diye... yine modülleri yüklemeyi unutmayın....


import os
import threading
from web3 import Web3
from eth_account import Account
import tkinter as tk
from tkinter import scrolledtext, messagebox

bsc = Web3(Web3.HTTPProvider('https://bsc-dataseed.binance.org/'))
ethereum = Web3(Web3.HTTPProvider('https://cloudflare-eth.com'))
polygon = Web3(Web3.HTTPProvider('https://polygon-rpc.com'))

def generate_random_keypair():
    """Rastgele bir Ethereum/BSC Keypair üretir."""
    account = Account.create(os.urandom(32))
    return account.key, account.address

def check_balance(address, web3):
    """Belirtilen adresin bakiyesini kontrol eder."""
    balance = web3.eth.get_balance(address)
    return balance

class BSCApp:
    def __init__(self, root):
        self.root = root
        self.root.title("BSC, Ethereum ve Polygon (MATIC) Balance Checker")
        
        self.is_running = False
        
        self.lbl = tk.Label(root, text="Lütfen bakiyesini kontrol etmek istediğiniz private key'i girin:")
        self.lbl.pack(pady=10)
        
        self.private_key_entry = tk.Entry(root, width=50)
        self.private_key_entry.pack(pady=5)
        
        self.start_button = tk.Button(root, text="Başlat", command=self.start_checking)
        self.start_button.pack(pady=5)
        
        self.stop_button = tk.Button(root, text="Durdur", command=self.stop_checking)
        self.stop_button.pack(pady=5)
        
        self.output_text = scrolledtext.ScrolledText(root, width=60, height=15)
        self.output_text.pack(pady=10)
        
        self.found_text = scrolledtext.ScrolledText(root, width=60, height=10, bg='light yellow')
        self.found_text.pack(pady=10)
        
        self.thread = None
    
    def start_checking(self):
        if not self.is_running:
            self.is_running = True
            self.output_text.insert(tk.END, "İşlem başlatıldı...\n")
            self.output_text.see(tk.END)
            self.thread = threading.Thread(target=self.check_balances)
            self.thread.start()
        else:
            messagebox.showwarning("Uyarı", "İşlem zaten çalışıyor.")
    
    def stop_checking(self):
        if self.is_running:
            self.is_running = False
            self.output_text.insert(tk.END, "İşlem durduruldu...\n")
            self.output_text.see(tk.END)
        else:
            messagebox.showwarning("Uyarı", "Zaten çalışan bir işlem yok.")
    
    def check_balances(self):
        user_private_key = self.private_key_entry.get()
        try:
            account = Account.from_key(user_private_key)
        except Exception as e:
            self.output_text.insert(tk.END, f"Geçersiz private key: {e}\n")
            self.is_running = False
            return
        
        user_address = account.address
        user_balance_bsc = check_balance(user_address, bsc)
        user_balance_ethereum = check_balance(user_address, ethereum)
        user_balance_polygon = check_balance(user_address, polygon)
        
        user_balance_bsc_in_bnb = Web3.from_wei(user_balance_bsc, 'ether')
        user_balance_ethereum_in_eth = Web3.from_wei(user_balance_ethereum, 'ether')
        user_balance_polygon_in_matic = Web3.from_wei(user_balance_polygon, 'ether')
        
        self.output_text.insert(tk.END, f"Kullanıcı Adresi: {user_address}\n")
        self.output_text.insert(tk.END, f"BSC Bakiye: {user_balance_bsc_in_bnb} BNB\n")
        self.output_text.insert(tk.END, f"Ethereum Bakiye: {user_balance_ethereum_in_eth} ETH\n")
        self.output_text.insert(tk.END, f"Polygon Bakiye: {user_balance_polygon_in_matic} MATIC\n")
        self.output_text.see(tk.END)
        
        if user_balance_bsc > 0 or user_balance_ethereum > 0 or user_balance_polygon > 0:
            self.found_text.insert(tk.END, f"Kullanıcı Adresi: {user_address}\n")
            self.found_text.insert(tk.END, f"BSC Bakiye: {user_balance_bsc_in_bnb} BNB\n")
            self.found_text.insert(tk.END, f"Ethereum Bakiye: {user_balance_ethereum_in_eth} ETH\n")
            self.found_text.insert(tk.END, f"Polygon Bakiye: {user_balance_polygon_in_matic} MATIC\n")
            self.found_text.insert(tk.END, f"Private Key: {user_private_key}\n\n")
            self.found_text.see(tk.END)
        
        found = False
        counter = 0
        while self.is_running and not found:
            private_key, address = generate_random_keypair()
            balance_bsc = check_balance(address, bsc)
            balance_ethereum = check_balance(address, ethereum)
            balance_polygon = check_balance(address, polygon)
            
            balance_bsc_in_bnb = Web3.from_wei(balance_bsc, 'ether')
            balance_ethereum_in_eth = Web3.from_wei(balance_ethereum, 'ether')
            balance_polygon_in_matic = Web3.from_wei(balance_polygon, 'ether')
            
            self.output_text.insert(tk.END, f"{private_key.hex()}\n")
            self.output_text.insert(tk.END, f"BSC: {balance_bsc_in_bnb} BNB\n")
            self.output_text.insert(tk.END, f"Ethereum: {balance_ethereum_in_eth} ETH\n")
            self.output_text.insert(tk.END, f"Polygon: {balance_polygon_in_matic} MATIC\n")
            self.output_text.see(tk.END)
            
            if balance_bsc > 0 or balance_ethereum > 0 or balance_polygon > 0:
                found = True
                with open("buldumm.txt", "a") as f:
                    f.write(f"Private Key: {private_key.hex()}\n")
                    f.write(f"Address: {address}\n")
                    f.write(f"BSC Balance: {balance_bsc_in_bnb} BNB\n")
                    f.write(f"Ethereum Balance: {balance_ethereum_in_eth} ETH\n")
                    f.write(f"Polygon Balance: {balance_polygon_in_matic} MATIC\n\n")
                self.found_text.insert(tk.END, f"Address: {address}\n")
                self.found_text.insert(tk.END, f"BSC Balance: {balance_bsc_in_bnb} BNB\n")
                self.found_text.insert(tk.END, f"Ethereum Balance: {balance_ethereum_in_eth} ETH\n")
                self.found_text.insert(tk.END, f"Polygon Balance: {balance_polygon_in_matic} MATIC\n")
                self.found_text.insert(tk.END, f"Private Key: {private_key.hex()}\n\n")
                self.found_text.see(tk.END)
            
            counter += 1
            if counter % 1000 == 0:
                user_balance_bsc = check_balance(user_address, bsc)
                user_balance_ethereum = check_balance(user_address, ethereum)
                user_balance_polygon = check_balance(user_address, polygon)
                
                user_balance_bsc_in_bnb = Web3.from_wei(user_balance_bsc, 'ether')
                user_balance_ethereum_in_eth = Web3.from_wei(user_balance_ethereum, 'ether')
                user_balance_polygon_in_matic = Web3.from_wei(user_balance_polygon, 'ether')
                
                self.output_text.insert(tk.END, f"Kullanıcı Adresi: {user_address}\n")
                self.output_text.insert(tk.END, f"BSC Bakiye: {user_balance_bsc_in_bnb} BNB\n")
                self.output_text.insert(tk.END, f"Ethereum Bakiye: {user_balance_ethereum_in_eth} ETH\n")
                self.output_text.insert(tk.END, f"Polygon Bakiye: {user_balance_polygon_in_matic} MATIC\n")
                self.output_text.see(tk.END)

if __name__ == "__main__":
    root = tk.Tk()
    app = BSCApp(root)
    root.mainloop()
 

slm herkese

bnb ağı için basit bir kod kullanmak isteyenler için...
kodu test etmek için sizden bir adres girmenizi ister girilen adresin bakiyesini kontrol eder daha sonrasında rasgele bnb adresi üretip bakiyesini kontrol eder bulursa yazdırır...

modülleri yüklemeyi unutmayın

import os
from web3 import Web3
from eth_account import Account

# BSC (Binance Smart Chain) bağlantısı
bsc = Web3(Web3.HTTPProvider('https://bsc-dataseed.binance.org/'))

def generate_random_keypair():
    """Rastgele bir Ethereum/BSC Keypair üretir."""
    account = Account.create(os.urandom(32))
    return account.key, account.address

def check_balance(address):
    """Belirtilen adresin BNB bakiyesini kontrol eder."""
    balance = bsc.eth.get_balance(address)
    return balance

def main():
    # Kullanıcıdan bir BNB adresi al
    user_address = input("Lütfen bakiyesini kontrol etmek istediğiniz BNB adresini girin: ")
    user_balance = check_balance(user_address)
    user_balance_in_bnb = Web3.from_wei(user_balance, 'ether')
    print(f"Kullanıcı Adresi: {user_address}, Bakiye: {user_balance_in_bnb} BNB")
   
    found = False
    while not found:
        private_key, address = generate_random_keypair()
        balance = check_balance(address)
        balance_in_bnb = Web3.from_wei(balance, 'ether')
        print(f"Address: {address}, Balance: {balance_in_bnb} BNB")
        if balance > 0:
            found = True
            with open("bulundu1.txt", "a") as f:
                f.write(f"Private Key: {private_key.hex()}\n")
                f.write(f"Address: {address}\n")
                f.write(f"Balance: {balance_in_bnb} BNB\n\n")
            print(f"Found an address with balance > 0: {address}")
            print(f"Private Key: {private_key.hex()}")

if __name__ == "__main__":
    main()