Homem processa conselho municipal em tentativa de recuperar HD descartado com 8.000 Bitcoins

Agência Brasil

Epoc Unit. USD      M   Conv. USD
---- ---------   ----   ------------
2008   ~0.0025 x 8000 = 
2009   0,00764 x 8000 = 
2010      0,40 x 8000 = 
2011      1,00 x 8000 = 
2011     30,00 x 8000 = 
2011      4,70 x 8000 = 
2012     13,50 x 8000 = 
2013     20,00 x 8000 = 
2013   1200,00 x 8000 = 
2024  71227,18 x 8000 = 
------------------------------------

Block         : 0
Hash          : 000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
Previous block: 0000000000000000000000000000000000000000000000000000000000000000
Next block    : 00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048
Timestamp     : 1231006505 (Time: 2009-01-03 18:15:05)
Difficulty    : 1 (Bits: 1d00ffff   The difficulty was '1' - AAAH so easy to mine back then
Transactions  : 1
Total BTC     : 50
Size          : 285 bytes
Merkle root   : 4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b
Nonce         : 2083236893

Tx Ids        : ["4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"]

Fonte: mempool.space API

Block         : 866666
Hash          : 000000000000000000022a3fa39d17cace368ab7054ab31e535ea1dfaaf7a40a
Previous block: 00000000000000000001f89d13fc989980ee5174a6c9aad5fd953ad00fd93da3
Next block    : 0000000000000000000115f8d93971ebfaefa1e9b10aea892fb4d364d4a1cb82
Timestamp     : 1729491372 (Time: 2024-10-21 06:16:12)
Difficulty    : 92049594548485.47 (Bits: 17030ecd)
Transactions  : 1
Total BTC     : 0
Size          : 475 bytes
Merkle root   : ec2d1b0357fc3e322a852c5b99081c679b965f9c7a1a9385a822eb717fa70ba0
Nonce         : 2904117257

Tx Ids        : ["ec2d1b0357fc3e322a852c5b99081c679b965f9c7a1a9385a822eb717fa70ba0"]

Fonte: mempool.space API

Fonte: investopedia.com

---< cut here
# Requires hashlib.  Execute with: python3 block_000000_ef_v3.py
import hashlib
import struct
import time
import sys

# Função para converter valores para formato little-endian
def little_endian(value, length):
    return value.to_bytes(length, byteorder='little')

# Função para realizar o hash duplo SHA256
def double_sha256(data):
    return hashlib.sha256(hashlib.sha256(data).digest()).digest()

# Função para converter bits para o valor target
def bits_to_target(bits):
    exponent = bits >> 24
    mantissa = bits & 0xffffff
    return mantissa * 2 ** (8 * (exponent - 3))

# Parâmetros do bloco 0
# Download a partir de https://mempool.space/api/blocks/<block_number>
# Ex.: wget -qO- https://mempool.space/api/blocks/0
#[
#    {
#        "id": "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
#        "height": 0,
#        "version": 1,
#        "timestamp": 1231006505,
#        "tx_count": 1,
#        "size": 285,
#        "weight": 1140,
#        "merkle_root": "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
#        "previousblockhash": null,
#        "mediantime": 1231006505,
#        "nonce": 2083236893,
#        "bits": 486604799,
#        "difficulty": 1
#    }
#]

version        = 1
previous_block_hash = '0000000000000000000000000000000000000000000000000000000000000000'
merkle_root    = '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b'

timestamp      = 1231006505  # 03/Jan/2009 18:15:05 UTC
#bits          = 0x1d00ffff  # Dificuldade compactada
bits           = 486604799
#nonce_start   = 2080000000  # Nonce inicial para teste
nonce_start    = 0           # Nonce inicial (@Intel 2.2GHz ~ 1h48m)
nonce_end      = 0xffffffff  # Max 4,294,967,296
print_interval = 1000000     # Quantidade de nonces para exibir progresso

# Converter bits para target
target = bits_to_target(bits)

# Pré-calcular a parte fixa do cabeçalho
fixed_header = (
    little_endian(version, 4) +
    bytes.fromhex(previous_block_hash)[::-1] +
    bytes.fromhex(merkle_root)[::-1] +
    little_endian(timestamp, 4) +
    little_endian(bits, 4)
)

# Informações iniciais
fixed_header_hex = fixed_header.hex()
print(f"Fixed header : {fixed_header_hex}")
print(f"Version      : {version}")
print(f"Timestamp    : {timestamp}")
print(f"Bits         : {bits}")
print(f"Start Nonce  : {nonce_start}")
print(f"End Nonce    : {nonce_end}")
print(f"Target       : {target}")

# Função principal com timing e cálculo de hashes/s
def mine_block():
    # Anotar o instante de início
    start_time = time.time()
    last_print_time = start_time
    print(f"Starting...  : {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(start_time))}.{int(start_time * 1000) % 1000} ms")
    
    for nonce in range(nonce_start, nonce_end + 1):
        # Atualizar apenas o nonce a cada iteração
        block_header = fixed_header + little_endian(nonce, 4)
        
        # Calcular o hash do cabeçalho do bloco
        block_hash = double_sha256(block_header)[::-1].hex()
        
        # Verificar se o hash é válido (atinge o target)
        if int(block_hash, 16) < target:
            print(f"Current Nonce: {nonce}, Curr. Hash: {block_hash},  !!! Found !!!")
            block_header_hex = block_header.hex()
            #nonce_hex = little_endian(nonce, 4).hex()
            #nonce_hex = nonce.hex()
            print(f"End Nonce hex: 0x{nonce:08x}\nBlk_hdr_hex  : {block_header_hex}")
            break

        # Mostrar progresso a cada print_interval
        if nonce % print_interval == 0:
            current_time = time.time()
            elapsed_since_last_print = current_time - last_print_time
            hashes_per_second = print_interval / elapsed_since_last_print
            print(f"Current Nonce: {nonce}, Curr. Hash: {block_hash},  ({hashes_per_second:.2f} hashes/s)")
            last_print_time = current_time
    
    # Anotar o instante de fim
    end_time = time.time()
    elapsed_time = end_time - start_time
    print(f"End mining.  : {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(end_time))}.{int(end_time * 1000) % 1000} ms")
    print(f"\nRunning Time : {elapsed_time:.3f} seconds. {nonce} calculated hashes")

# Invoca a função
mine_block()
---< cut here

Um texto.

Uma citação ipsis litteris, por exemplo.

Fonte: arkhamintelligence.com

Fonte: bitref.com

• A maioria das carteiras de criptomoedas são dispositivos que usam software e hardware, portanto, às vezes, os hackers podem obter acesso a essas ferramentas de armazenamento, apesar das medidas de segurança projetadas para evitar roubos.
• As carteiras frias são uma forma de manter as chaves de criptomoeda offline, e algumas das melhores carteiras de software criptográfico também oferecem armazenamento frio.
• Ao usar uma carteira fria, os usuários e investidores de criptomoedas evitam roubos por hackers que podem obter o controle de suas carteiras quentes por meio de vírus, malware, ransomware ou outros métodos.
  Fonte: investopedia.com

    gcc -O1 double_sha256_test.c sha256-x8664.S -o double_sha256-test

Fonte: bitref.com (query @20241025T0820Z)