---

@CanalQb no YouTube

---

Guia Completo para Gerar e Validar Chaves Privadas Bitcoin SV com Python

---

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

---

Guia Completo para Gerar e Validar Chaves Privadas Bitcoin SV com Python

Este artigo apresenta um tutorial detalhado para gerar chaves públicas comprimidas a partir de chaves privadas e validar endereços Bitcoin SV (BSV) utilizando Python. A abordagem técnica é ideal para desenvolvedores, pesquisadores e entusiastas de criptomoedas que desejam aprofundar seu conhecimento em segurança e funcionamento do ecossistema Bitcoin SV.

Introdução ao Bitcoin SV

Bitcoin SV é uma criptomoeda que surgiu como um fork do Bitcoin Cash, focada em manter a visão original do Bitcoin proposta por Satoshi Nakamoto, priorizando escalabilidade e usabilidade comercial. Entender como gerar e validar endereços é essencial para quem trabalha com wallets, aplicações blockchain e segurança digital.

Detalhes Técnicos do Script

1. Geração da Chave Pública Comprimida

Utilizando a biblioteca ecdsa e a curva SECP256k1, o script converte uma chave privada (inteiro) em uma chave pública comprimida. A compressão reduz o tamanho da chave pública para 33 bytes, usando prefixos 0x02 ou 0x03 conforme a paridade da coordenada y.

2. Conversão da Chave Pública em Endereço Bitcoin SV

O processo de conversão envolve múltiplas etapas:

1. Aplicar hash SHA-256 na chave pública comprimida.
2. Aplicar hash RIPEMD-160 no resultado do SHA-256.
3. Adicionar prefixo 0x00 para indicar rede principal (mainnet) do Bitcoin SV.
4. Gerar checksum com duas rodadas de SHA-256 e anexar os primeiros 4 bytes.
5. Codificar o resultado final em Base58 para obter o endereço legível.

3. Validação da Chave Privada

A função de validação verifica se o valor inteiro da chave privada está dentro do intervalo permitido pela curva SECP256k1. Além disso, assegura que o endereço gerado começa com o caractere 1, característico dos endereços Bitcoin SV mainnet.

Exemplo Prático: Verificação em um Intervalo de Chaves

O script examina um intervalo de chaves privadas em hexadecimal de 0x2000 até 0x3fff. Para cada chave, valida sua integridade, gera a chave pública e o endereço, e verifica se corresponde a um endereço específico desejado.

inicio = int('2000', 16)
fim = int('3fff', 16)
valid_keys = 0
invalid_keys = 0

for private_key_int in range(inicio, fim + 1):
    if is_valid_private_key(private_key_int):
        valid_keys += 1
        public_key = private_key_to_public_key_compressed(private_key_int)
        address = public_key_to_address(public_key)
        if address == '1ErZWg5cFCe4Vw5BzgfzB74VNLaXEiEkhk':
            print(f"Endereço encontrado: {address}")
            print(f"Private Key: 0x{private_key_int:064x}")
            sys.exit()
        print(f"Private Key: 0x{private_key_int:064x} - Bitcoin SV Address: {address}")
    else:
        invalid_keys += 1

print(f"Total de chaves válidas: {valid_keys}")
print(f"Total de chaves inválidas: {invalid_keys}")

Considerações Importantes

Este tutorial tem caráter educativo e técnico. O uso real de chaves privadas deve ser feito com extrema cautela para evitar riscos financeiros e de segurança. Nunca compartilhe suas chaves privadas, utilize ferramentas confiáveis e realize análises individuais antes de investir ou utilizar criptomoedas.

Referências Oficiais

• Biblioteca ecdsa no GitHub
• Formato oficial de endereço Bitcoin
• Bitcoin SV - Site oficial

Script Completo em Python para Gerar e Validar Endereços Bitcoin SV

import hashlib
from ecdsa import SECP256k1
import sys  # Para encerrar o script

def private_key_to_public_key_compressed(private_key):
    public_key_point = SECP256k1.generator * private_key
    if public_key_point.y() % 2 == 0:
        public_key_bytes = b'\x02' + public_key_point.x().to_bytes(32, byteorder='big')
    else:
        public_key_bytes = b'\x03' + public_key_point.x().to_bytes(32, byteorder='big')
    return public_key_bytes

def public_key_to_address(public_key):
    sha256_hash = hashlib.sha256(public_key).digest()
    ripemd160_hash = hashlib.new("ripemd160", sha256_hash).digest()
    prefixed = b'\x00' + ripemd160_hash
    checksum = hashlib.sha256(hashlib.sha256(prefixed).digest()).digest()[:4]
    address = prefixed + checksum

    alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
    num = int.from_bytes(address, 'big')

    encoded_address = ''
    while num > 0:
        num, mod = divmod(num, 58)
        encoded_address = alphabet[mod] + encoded_address

    n = 0
    for byte in address:
        if byte == 0:
            n += 1
        else:
            break
    return alphabet[0] * n + encoded_address

def is_valid_private_key(private_key_int):
    if private_key_int <= 0 or private_key_int >= SECP256k1.order:
        return False
    public_key = private_key_to_public_key_compressed(private_key_int)
    address = public_key_to_address(public_key)
    return address[0] == '1'

inicio = int('2000', 16)
fim = int('3fff', 16)

valid_keys = 0
invalid_keys = 0

for private_key_int in range(inicio, fim + 1):
    if is_valid_private_key(private_key_int):
        valid_keys += 1
        public_key = private_key_to_public_key_compressed(private_key_int)
        address = public_key_to_address(public_key)
        if address == '1ErZWg5cFCe4Vw5BzgfzB74VNLaXEiEkhk':
            print(f"Endereço encontrado: {address}")
            print(f"Private Key: 0x{private_key_int:064x}")
            sys.exit()
        print(f"Private Key: 0x{private_key_int:064x} - Bitcoin SV Address: {address}")
    else:
        invalid_keys += 1

print(f"\nTotal de chaves válidas: {valid_keys}")
print(f"Total de chaves inválidas: {invalid_keys}")