Como Conectar PostgreSQL com Python e Converter Chaves Privadas em WIF

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

Como Conectar PostgreSQL com Python e Converter Chaves Privadas em WIF

Este artigo explica como estabelecer uma conexão segura com um banco de dados PostgreSQL utilizando Python, realizar consultas para selecionar dados aleatórios e processar intervalos numéricos. Além disso, aborda a conversão de chaves privadas em formato hexadecimal para o padrão WIF (Wallet Import Format), amplamente usado em criptomoedas como Bitcoin.

1. Conectando ao Banco de Dados PostgreSQL

Usamos a biblioteca pg8000 para conexão, que é uma implementação nativa Python para PostgreSQL, compatível com SSL e segura para produção. A URL de conexão deve conter as credenciais e o host, garantindo a segurança com sslmode=require.

import pg8000
import urllib.parse

DATABASE_URL = "postgres://usuario:senha@host:porta/banco?sslmode=require"

def conectar_ao_banco():
    try:
        url = urllib.parse.urlparse(DATABASE_URL)
        return pg8000.connect(
            user=url.username,
            password=url.password,
            host=url.hostname,
            database=url.path[1:],  # Remove a barra inicial
            port=5432,
            ssl_context=True
        )
    except Exception as e:
        print(f"Erro ao conectar ao banco de dados: {e}")
        raise

Essa função estabelece a conexão e levanta exceções para facilitar a depuração.

2. Seleção Aleatória de Dados com Intervalo de Atualização

Para garantir dados atualizados, a consulta SQL busca linhas onde o campo datahora esteja vazio ou com mais de 3 horas desde a última atualização:

SELECT * FROM puzzle67 
WHERE datahora IS NULL OR (CURRENT_TIMESTAMP - datahora) > INTERVAL '3 HOURS' 
ORDER BY RANDOM() LIMIT 1;

Esse método é útil para dividir o processamento em ranges que podem ser atualizados periodicamente.

3. Manipulação de Intervalos e Divisão em Partes

Após obter o intervalo inicial e final em hexadecimal, convertemos para inteiros e dividimos em 10 partes iguais para facilitar o processamento em blocos menores. Exemplo:

range_inicial = int(inicio_range, 16)
fim_range = int(fim_range, 16)
tamanho_parte = (fim_range - range_inicial) // 10

for i in range(10):
    inicio_parte = range_inicial + i * tamanho_parte
    fim_parte = fim_range if i == 9 else inicio_parte + tamanho_parte
    print(f"Parte {i+1}: de {hex(inicio_parte)} até {hex(fim_parte)}")

4. Conversão de Chaves Privadas para WIF

O formato WIF é essencial para carteiras Bitcoin, incluindo um checksum para validar a chave. A função abaixo realiza a conversão seguindo o padrão:

import hashlib

def private_key_to_wif(private_key_hex, compression='01'):
    if private_key_hex.startswith('0x'):
        private_key_hex = private_key_hex[2:]

    private_key = bytes.fromhex(private_key_hex.zfill(64))
    data = b'\x80' + private_key + bytes([int(compression, 16)])

    hash1 = hashlib.sha256(data).digest()
    hash2 = hashlib.sha256(hash1).digest()
    checksum = hash2[:4]

    data += checksum

    characters = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
    i = int.from_bytes(data, 'big')
    base58 = ''
    while i > 0:
        i, remainder = divmod(i, 58)
        base58 = characters[remainder] + base58

    return base58

Esse código gera o WIF correspondente à chave privada hexadecimal, incluindo o byte de versão e compressão.

5. Estimativa de Tempo para Processamento de Conversões

O script mede o tempo gasto para converter uma chave e calcula quantas conversões podem ser feitas por segundo, minuto e hora. Com base nisso, estima o tempo restante para processar toda a faixa de chaves, dividida em 10% para facilitar o acompanhamento do progresso.

6. Contagem Regressiva e Processamento Parcial

Para controle, é implementada uma contagem regressiva simples antes do processamento, e a execução é interrompida após alcançar 10% do total das chaves, garantindo eficiência e evitando sobrecarga.

Considerações Finais

Este código é uma base para quem deseja trabalhar com integrações entre Python e bancos de dados PostgreSQL, especialmente em projetos envolvendo criptografia e blockchain.

Atenção: Se você planeja usar essa abordagem para fins de investimento ou mineração, faça uma análise cuidadosa dos riscos envolvidos e nunca invista dinheiro que não possa perder.

Formulário de contato

Como Conectar PostgreSQL com Python e Converter Chaves Privadas em WIF