Neural Programmers </>

MY NETWORK 

T.me/MR_K_NETWORK

#Dev Mr.K
#Tg : T.me/MR_K_NETWORK 

import os
import binascii
import requests
from Crypto.Hash import keccak
from eth_utils import to_checksum_address
from ecdsa import SigningKey, SECP256k1

def private_key_to_public_key(private_key):
    private_key_bytes = binascii.unhexlify(private_key)
    private_key_object = SigningKey.from_string(private_key_bytes, curve=SECP256k1)
    public_key_object = private_key_object.get_verifying_key()
    public_key_bytes = public_key_object.to_string()
    public_key = binascii.hexlify(public_key_bytes)
    return public_key

def public_key_to_address(public_key):
    public_key_bytes = binascii.unhexlify(public_key)
    keccak_hash = keccak.new(digest_bits=256)
    keccak_hash.update(public_key_bytes)
    hashed_key = keccak_hash.hexdigest()
    address = hashed_key[-40:]
    return to_checksum_address(address)

def generate_etc_address():
    private_key = binascii.hexlify(os.urandom(32)).decode('utf-8')
    public_key = private_key_to_public_key(private_key)
    address = public_key_to_address(public_key)
    return (address, private_key)

def get_balance(address):
    api_url = f'https://blockscout.com/etc/mainnet/api?module=account&action=balance&address={address}'
    response = requests.get(api_url)
    data = response.json()
    balance = int(data['result']) / 10**18
    return balance

def save_to_file(address, private_key, balance):
    with open('found.txt', 'a') as f:
        f.write(f'Ethereum Classic Address: {address}\n')
        f.write(f'Private Key: {private_key}\n')
        f.write(f'Balance: {balance} ETC\n\n')

if name == 'main':
    try:
        while True:
            address, private_key = generate_etc_address()
            balance = get_balance(address)
            print('Ethereum Classic Address:', address)
            print('Private Key:', private_key)
            print('Balance:', balance, 'ETC')
            if balance > 0:
                save_to_file(address, private_key, balance)
                print('Address with balance saved to found.txt')
    except KeyboardInterrupt:
        print('\nStopped by user.')
#Dev Mr.K
#Tg : T.me/MR_K_NETWORK

#DEVELOPED BY MR.K
#TG @K_HACKER_ANONYMOUS 

import requests
from hdwallet import HDWallet
from hdwallet.symbols import BTC
from hdwallet.utils import generate_mnemonic
from colorama import init, Fore
import threading
import asyncio

# Initialization of Colorama
init()

# Bitcoin API Endpoint
BTC_API_ENDPOINT = "https://blockstream.info/api/address/"

#TG HIT SENDER
# Telegram Bot Token
BOT_TOKEN = "YOUR_BOT_TOKEN_HERE"
# User's Telegram Chat ID
CHAT_ID = "YOUR_CHAT_ID_HERE"

# Function for processing the generated wallet
async def process_wallet(counter):
    try:
        mnemonic = generate_mnemonic(language="english", strength=128)
        print(Fore.MAGENTA + f"Mnemonic Phrase: {mnemonic}" + Fore.RESET)

        hd_wallet_btc = HDWallet(symbol=BTC)
        hd_wallet_btc.from_mnemonic(mnemonic=mnemonic)
        btc_address = hd_wallet_btc.p2pkh_address()
        print(Fore.YELLOW + f"Bitcoin Address: {btc_address}" + Fore.RESET)

        # API request to check balance
        response = requests.get(BTC_API_ENDPOINT + btc_address)
        if response.status_code == 200:
            data = response.json()
            balance = data['chain_stats']['funded_txo_sum'] / 100000000
            if balance > 0:
                print(Fore.GREEN + f"Balance: {balance} BTC" + Fore.RESET)
                with open("balances.txt", "a") as file:
                    file.write(f"Mnemonic Phrase: {mnemonic}\n")
                    file.write(f"Bitcoin Address: {btc_address}\n")
                    file.write(f"Balance: {balance} BTC\n\n")
                await send_message_to_telegram(btc_address, mnemonic, balance)  # Send message to Telegram
            else:
                print(Fore.RED + "No balance found." + Fore.RESET)
        else:
            print(Fore.RED + "Error in API response." + Fore.RESET)

        print(Fore.CYAN + f"Number of generated wallets: {counter}" + Fore.RESET)

    except Exception as e:
        print(Fore.RED + f"Error processing the generated wallet: {e}" + Fore.RESET)

# Function to check if the API is working
async def check_api():
    try:
        response = requests.get(BTC_API_ENDPOINT + "1BoatSLRHtKNngkdXEeobR76b53LETtpyT")
        if response.status_code == 200:
            data = response.json()
            balance = data['chain_stats']['funded_txo_sum'] / 100000000
            print(Fore.GREEN + f"API is working. Balance: {balance} BTC" + Fore.RESET)
        else:
            print(Fore.RED + "Error in API response." + Fore.RESET)
    except Exception as e:
        print(Fore.RED + f"Error checking the API: {e}" + Fore.RESET)

# Function to send message to Telegram
async def send_message_to_telegram(btc_address, mnemonic, balance):
    try:
        message = f"Bitcoin Address: {btc_address}\n"
        message += f"Mnemonic Phrase: {mnemonic}\n"
        message += f"Balance: {balance} BTC\n"
        requests.get(f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage?chat_id={CHAT_ID}&text={message}")
    except Exception as e:
        print(Fore.RED + f"Error sending message to Telegram: {e}" + Fore.RESET)

# Main function
async def main():
    # Send message to Telegram on startup
    await send_message_to_telegram("N/A", "N/A", "N/A")

    # Check API before generating wallets
    await check_api()

    counter = 0  # Counter for generated wallets

    while True:
        try:
            threads = []
            for _ in range(500):  # Number of threads for concurrent processing of generated wallets
                thread = threading.Thread(target=lambda: asyncio.run(process_wallet(counter)))
                thread.start()
                threads.append(thread)
                counter += 1

            for thread in threads:
                thread.join()

        except KeyboardInterrupt:
            print(Fore.YELLOW + "Program manually terminated." + Fore.RESET)
            break
        except Exception as e:
            print(Fore.RED + f"Unexpected error in the main program: {e}" + Fore.RESET)

if name == "main":
    asyncio.run(main())