@CanalQb no YouTube

Como gerar endereços BTC e ETH a partir de mnemônicas com Firebase

Sempre crie uma frase de segurança única para jogos, testnets ou airdrops e evite usar sua carteira principal.

Geração de Endereços Bitcoin e Ethereum Usando Frases Mnemônicas

Este artigo demonstra como automatizar a geração de chaves privadas e endereços Bitcoin (BTC) e Ethereum (ETH) a partir de frases mnemônicas BIP-39, usando Firebase como banco de dados em tempo real e bibliotecas Python como bip_utils, bit e eth_account.

Objetivo

O script abaixo acessa frases mnemônicas armazenadas no Firebase, gera chaves privadas, converte-as para formato WIF, cria os respectivos endereços BTC e ETH, consulta saldos via APIs e remove automaticamente entradas inativas.

Dependências utilizadas

• requests
• bs4 (BeautifulSoup)
• hashlib
• bit
• random
• firebase_admin
• bip_utils
• ecdsa
• sha3
• coincurve
• base58
• eth_account

Código Python completo

import requests
from bs4 import BeautifulSoup
import hashlib
import bit
import random
import time
import firebase_admin
from firebase_admin import credentials, db
from bip_utils import Bip39SeedGenerator, Bip39MnemonicValidator, Bip39Languages, Bip44, Bip44Changes, Bip44Coins
from ecdsa import SigningKey, SECP256k1
from sha3 import keccak_256
from coincurve import PublicKey
import base58
from eth_account import Account

def private_key_to_wif(privatekey, compression='01'):
    try:
        privatekey = privatekey.zfill(64)
        data = "80" + privatekey + compression
        hash1 = hashlib.sha256(bytes.fromhex(data)).digest()
        hash2 = hashlib.sha256(hash1).hexdigest()
        checksum = hash2[0:8]
        data = data + checksum
        characters = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
        i = int(data, 16)
        base58_result = ''
        while i > 0:
            i, remainder = divmod(i, 58)
            base58_result = characters[remainder] + base58_result
        return base58_result
    except Exception as e:
        print(f"Erro na conversão para WIF: {e}")
        return None

def ripemd160_sha256(data):
    try:
        return hashlib.new('ripemd160', hashlib.sha256(data).digest()).digest()
    except Exception as e:
        print(f"Erro no RIPEMD-160: {e}")
        return None

def public_key_to_btc_address(public_key):
    try:
        sha256_pubkey = hashlib.sha256(public_key).digest()
        ripemd160_pubkey = ripemd160_sha256(sha256_pubkey)
        network_byte = b'\x00'
        address_bytes = network_byte + ripemd160_pubkey
        checksum = hashlib.sha256(hashlib.sha256(address_bytes).digest()).digest()[:4]
        return base58.b58encode(address_bytes + checksum).decode('utf-8')
    except Exception as e:
        print(f"Erro ao gerar endereço BTC: {e}")
        return None

def private_key_to_eth_address(private_key):
    try:
        acct = Account.from_key(private_key)
        return acct.address
    except Exception as e:
        print(f"Erro ao gerar endereço ETH: {e}")
        return None

cred = credentials.Certificate('carteirasmn.json')
firebase_admin.initialize_app(cred, {
    'databaseURL': 'https://carteiras-6e5dd-default-rtdb.firebaseio.com/'
})

for i in range(1, 100001):
    batch_number = random.randint(1, 2466)
    random_number = random.randint(0, 9999)
    ref = db.reference(f'mnemonics/batch_{batch_number}/{random_number}')
    
    dados = ref.get()
    if dados:
        frase = dados.get('frase', 'Frase não encontrada')
        privatekey = dados.get('privatekey', None)
        print(f'Frase: {frase}')

        if privatekey:
            continue
        else:
            try:
                seed_bytes = Bip39SeedGenerator(frase).Generate()
                bip44_mst_ctx = Bip44.FromSeed(seed_bytes, Bip44Coins.ETHEREUM)
                bip44_coin_ctx = bip44_mst_ctx.Purpose().Coin()
                bip44_addr_ctx = bip44_coin_ctx.Account(0).Change(Bip44Changes.CHAIN_EXT).AddressIndex(0)
                privatekey = bip44_addr_ctx.PrivateKey().Raw().ToHex()
                ref.set({'frase': frase, 'privatekey': privatekey})
            except Exception as e:
                continue
        
        generated_wif = private_key_to_wif(privatekey)
        if generated_wif:
            public_key = bit.PrivateKey(generated_wif).public_key
            public_key_hash = ripemd160_sha256(public_key)
            segwit_addr = public_key_to_btc_address(public_key_hash)
            eth_address = private_key_to_eth_address(privatekey)
            print(f"Chave ETH: {eth_address} - Chave BTC: {segwit_addr}")
        else:
            print("Erro ao gerar WIF.")
    else:
        print('Dados não encontrados no Firebase.')

    countTxs = 0
    total_received = 0

    urleth = f"https://api.ethplorer.io/getAddressInfo/{eth_address}?apiKey=freekey&showETHTotals=true&showTxsCount=true"
    responseeth = requests.get(urleth)
    if responseeth.status_code == 200:
        data = responseeth.json()
        countTxs = data.get("countTxs", 0)
    else:
        print(f"Erro na requisição: {responseeth.status_code}")
        sys.exit(1)

    urlbtc = f"https://blockchain.info/balance?active={segwit_addr}"
    responsebtc = requests.get(urlbtc)

    if responsebtc.status_code == 200:
        data = responsebtc.json()
        total_received = data.get(segwit_addr, {}).get("total_received", 0)
    else:
        print(f"Erro na requisição: {responsebtc.status_code}")
        sys.exit(1)

    if total_received + countTxs == 0:
        try:
            ref.delete()
            print(f"Linha {ref.path} deletada do Firebase.")
        except Exception as e:
            print(f"Erro ao deletar do Firebase: {e}")
    else:
        print(f"A soma de total_received + countTxs não é 0.")

Responsabilidade e análise

Este conteúdo é voltado para estudo e aprendizado técnico. Antes de realizar qualquer ação com chaves privadas ou frases mnemônicas, entenda totalmente os riscos. Jamais reutilize exemplos de chaves em ambientes reais.

Fontes e links úteis

• Repositório oficial do BipUtils
• API do Blockchain.info
• API do Ethplorer
• Firebase Google