display merkle root and previous hash in hex

karask · karask · commit 794cd78bdec3 · 2024-06-26T10:53:47.000+03:00
diff --git a/bitcoinutils/block.py b/bitcoinutils/block.py
@@ -1,25 +1,17 @@
 import struct
 import hashlib
-from typing import Optional,Union
-from datetime import datetime,timezone
+from typing import Optional, Union
+from datetime import datetime, timezone
 
-from bitcoinutils.utils import (
-    h_to_b,
-    parse_compact_size,
-    get_transaction_length
-)
+from bitcoinutils.utils import h_to_b, parse_compact_size, get_transaction_length
 
-from bitcoinutils.transactions import(
-    Transaction
-)
+from bitcoinutils.transactions import Transaction
 
-from bitcoinutils.constants import(
-    HEADER_SIZE,
-    BLOCK_MAGIC_NUMBER
-)
+from bitcoinutils.constants import HEADER_SIZE, BLOCK_MAGIC_NUMBER
 
 import os
 
+
 class BlockHeader:
     """
     Represents a Bitcoin block header. This class encapsulates the details of a block's header
@@ -68,13 +60,13 @@ class BlockHeader:
 
     def __init__(
         self,
-        version : Optional[int] = None,
-        previous_block_hash : Optional[bytes] = None,
-        merkle_root : Optional[bytes] = None,
-        timestamp : Optional[int] = None,
-        target_bits : Optional[int] = None,
-        nonce : Optional[int] = None
-    ) -> None :
+        version: Optional[int] = None,
+        previous_block_hash: Optional[bytes] = None,
+        merkle_root: Optional[bytes] = None,
+        timestamp: Optional[int] = None,
+        target_bits: Optional[int] = None,
+        nonce: Optional[int] = None,
+    ) -> None:
         """
         Initializes a new BlockHeader object with specified attributes for a Bitcoin block.
 
@@ -117,22 +109,29 @@ def from_raw(rawhexdata: Union[str, bytes]):
             rawdata = rawhexdata
         else:
             raise TypeError("Input must be a hexadecimal string or bytes")
-        
-        #format String for struct packing/unpacking for block header
-        header_format = '<' # little-edian
-        header_format += 'I' # version (4 bytes) 
-        header_format += '32s' # previous block hash (32 bytes) 
-        header_format += '32s' # merkle root (32 bytes)
-        header_format += 'I' # timestamp (4 bytes)
-        header_format += 'I' # target bits (4 bytes)
-        header_format += 'I' # nonce (4 bytes)
+
+        # format String for struct packing/unpacking for block header
+        header_format = "<"  # little-edian
+        header_format += "I"  # version (4 bytes)
+        header_format += "32s"  # previous block hash (32 bytes)
+        header_format += "32s"  # merkle root (32 bytes)
+        header_format += "I"  # timestamp (4 bytes)
+        header_format += "I"  # target bits (4 bytes)
+        header_format += "I"  # nonce (4 bytes)
 
         if len(rawdata) != HEADER_SIZE:
             raise ValueError(f"Incorrect data length. Expected {HEADER_SIZE} bytes.")
-        
-        version,previous_block_hash,merkle_root,timestamp,target_bits,nonce= struct.unpack(header_format,rawdata)
-        previous_block_hash = previous_block_hash[::-1] #natural byte order
-        merkle_root = merkle_root[::-1] #natural byte order
+
+        (
+            version,
+            previous_block_hash,
+            merkle_root,
+            timestamp,
+            target_bits,
+            nonce,
+        ) = struct.unpack(header_format, rawdata)
+        previous_block_hash = previous_block_hash[::-1]  # natural byte order
+        merkle_root = merkle_root[::-1]  # natural byte order
 
         return BlockHeader(
             version=version,
@@ -142,7 +141,7 @@ def from_raw(rawhexdata: Union[str, bytes]):
             target_bits=target_bits,
             nonce=nonce,
         )
-    
+
     def __str__(self) -> str:
         """
         Returns a string representation of the BlockHeader, presenting all header information in a readable format.
@@ -164,18 +163,18 @@ def __str__(self) -> str:
 
     def __repr__(self) -> str:
         return self.__str__()
-    
+
     def get_version(self) -> Optional[int]:
         """Returns the block version, or None if not set."""
         return self.version if self.version is not None else None
 
     def get_previous_block_hash(self) -> Optional[bytes]:
         """Returns the previous block hash as bytes, or None if not set."""
-        return self.previous_block_hash if self.previous_block_hash else None
+        return self.previous_block_hash.hex() if self.previous_block_hash else None
 
     def get_merkle_root(self) -> Optional[bytes]:
         """Returns the merkle root as bytes, or None if not set."""
-        return self.merkle_root if self.merkle_root else None
+        return self.merkle_root.hex() if self.merkle_root else None
 
     def get_timestamp(self) -> Optional[int]:
         """Returns the block timestamp, or None if not set."""
@@ -188,32 +187,32 @@ def get_target_bits(self) -> Optional[int]:
     def get_nonce(self) -> Optional[int]:
         """Returns the nonce used for mining, or None if not set."""
         return self.nonce if self.nonce is not None else None
-    
+
     def format_timestamp(self):
         """
         Formats the block's timestamp into a human-readable UTC datetime string.
 
         Returns:
             str: The formatted UTC datetime string representing the block's timestamp.
         """
-         
+
         # A timezone-aware datetime object in UTC
         utc_time = datetime.fromtimestamp(self.timestamp, timezone.utc)
         return utc_time.strftime("%Y-%m-%d %H:%M:%S UTC")
-    
+
     def get_target_bits(self):
         """
         Decodes the compact representation of the target bits into the full target hash
         that a block's hash must be less than or equal to, in order to solve the block.
-        
+
         Returns:
             str: The target value as a 64-character hexadecimal string, representing
                 the full 256-bit target hash used in the proof of work.
         """
-        
+
         # Extract the exponent (first byte) and coefficient (last three bytes) from the target_bits
         exponent = self.target_bits >> 24
-        coefficient = self.target_bits & 0xffffff
+        coefficient = self.target_bits & 0xFFFFFF
 
         # Calculate the target by shifting the coefficient by (exponent - 3) * 8 bits to the left
         target = coefficient << (8 * (exponent - 3))
@@ -225,17 +224,25 @@ def get_target_bits(self):
     def serialize_header(self):
         """Serializes the block header in the format required for hashing."""
         # Ensure previous_block_hash and merkle_root are in byte form
-        prev_hash = self.previous_block_hash if isinstance(self.previous_block_hash, bytes) else bytes.fromhex(self.previous_block_hash)
-        merkle_root = self.merkle_root if isinstance(self.merkle_root, bytes) else bytes.fromhex(self.merkle_root)
+        prev_hash = (
+            self.previous_block_hash
+            if isinstance(self.previous_block_hash, bytes)
+            else bytes.fromhex(self.previous_block_hash)
+        )
+        merkle_root = (
+            self.merkle_root
+            if isinstance(self.merkle_root, bytes)
+            else bytes.fromhex(self.merkle_root)
+        )
 
         # Block header data is serialized in little-endian byte order
         header_data = (
-            struct.pack('<I', self.version) +
-            prev_hash[::-1] +  # reverse to little-endian
-            merkle_root[::-1] +  # reverse to little-endian
-            struct.pack('<I', self.timestamp) +
-            struct.pack('<I', self.target_bits) +
-            struct.pack('<I', self.nonce)
+            struct.pack("<I", self.version)
+            + prev_hash[::-1]
+            + merkle_root[::-1]  # reverse to little-endian
+            + struct.pack("<I", self.timestamp)  # reverse to little-endian
+            + struct.pack("<I", self.target_bits)
+            + struct.pack("<I", self.nonce)
         )
         return header_data
 
@@ -247,6 +254,7 @@ def get_block_hash(self):
         # Bitcoin block hashes are displayed in big-endian hex, but calculated in little-endian
         return hash_two[::-1].hex()  # reverse to big-endian and convert to hex string
 
+
 class Block:
     """
     Represents a Bitcoin block, encapsulating the block's fundamental components including
@@ -304,11 +312,11 @@ class Block:
 
     def __init__(
         self,
-        magic : Optional[bytes] = None,
-        block_size : Optional[int] = None,
-        header : Optional[BlockHeader] = None,
-        transaction_count : Optional[int] = None,
-        transactions : Optional[list[Transaction]] = None 
+        magic: Optional[bytes] = None,
+        block_size: Optional[int] = None,
+        header: Optional[BlockHeader] = None,
+        transaction_count: Optional[int] = None,
+        transactions: Optional[list[Transaction]] = None,
     ):
         """
         Initializes a new instance of Block, setting up all the necessary attributes that define a Bitcoin block.
@@ -328,7 +336,7 @@ def __init__(
         self.transactions = transactions
 
     @staticmethod
-    def from_raw(rawhexdata : Union[str,bytes]):
+    def from_raw(rawhexdata: Union[str, bytes]):
         """
         Constructs a Block instance from raw block data in hexadecimal or byte format.
 
@@ -351,42 +359,48 @@ def from_raw(rawhexdata : Union[str,bytes]):
         else:
             raise TypeError("Input must be a hexadecimal string or bytes")
         magic = rawdata[0:4]
-        block_size = struct.unpack('<I', rawdata[4:8])[0]
-        block_size = block_size 
-        header = BlockHeader.from_raw(rawdata[8:8 + HEADER_SIZE])
+        block_size = struct.unpack("<I", rawdata[4:8])[0]
+        block_size = block_size
+        header = BlockHeader.from_raw(rawdata[8 : 8 + HEADER_SIZE])
 
         # Handling the transaction counter which is a CompactSize
         transaction_count, tx_offset = parse_compact_size(rawdata[88:])
         transactions = []
         current_offset = 88 + tx_offset
         for i in range(transaction_count):
             try:
-                tx_length = get_transaction_length(rawdata[current_offset:]) 
-                transactions.append(Transaction.from_raw(rawdata[current_offset:current_offset + tx_length].hex()))
-                temp = Transaction.from_raw(rawdata[current_offset:current_offset + tx_length].hex())
+                tx_length = get_transaction_length(rawdata[current_offset:])
+                transactions.append(
+                    Transaction.from_raw(
+                        rawdata[current_offset : current_offset + tx_length].hex()
+                    )
+                )
+                temp = Transaction.from_raw(
+                    rawdata[current_offset : current_offset + tx_length].hex()
+                )
                 current_offset += tx_length
-                
+
             except Exception as e:
                 print(e)
-                print(i,transaction_count)
+                print(i, transaction_count)
                 break
 
         return Block(magic, block_size, header, transaction_count, transactions)
-    
+
     def __str__(self) -> str:
         return str(
             {
                 "magic": self.magic.hex(),
                 "block size": self.block_size,
                 "block header": self.header,
                 "trasaction count": self.transaction_count,
-                "transactions": self.transactions
+                "transactions": self.transactions,
             }
         )
 
     def __repr__(self) -> str:
         return self.__str__()
-    
+
     def get_magic_bytes(self) -> tuple[str, str]:
         """
         Retrieves the magic bytes and its corresponding network description.
@@ -402,8 +416,8 @@ def get_magic_bytes(self) -> tuple[str, str]:
             raise ValueError("Magic bytes are not set.")
 
         magic_hex = self.magic.hex()
-        return (magic_hex,BLOCK_MAGIC_NUMBER[magic_hex])
-        
+        return (magic_hex, BLOCK_MAGIC_NUMBER[magic_hex])
+
     def get_block_size(self) -> int:
         """
         Retrieves the size of the block in bytes.
@@ -414,7 +428,7 @@ def get_block_size(self) -> int:
 
         return self.block_size
 
-    def get_block_header(self) -> BlockHeader :
+    def get_block_header(self) -> BlockHeader:
         """
         Retrieves the header of the block.
 
@@ -427,7 +441,7 @@ def get_block_header(self) -> BlockHeader :
         if self.header is None:
             raise ValueError("Block header is not set.")
         return self.header
-    
+
     def get_transactions(self) -> list[Transaction]:
         """
         Retrieves the transactions contained in the block.
@@ -442,8 +456,8 @@ def get_transactions(self) -> list[Transaction]:
         if self.transactions is None:
             raise ValueError("No transactions given.")
         return self.transactions
-    
-    def get_transactions_count(self) -> int :
+
+    def get_transactions_count(self) -> int:
         """
         Retrieves the number of transactions in the block.
 
@@ -457,7 +471,7 @@ def get_transactions_count(self) -> int :
         if self.transactions is None:
             raise ValueError("No transactions given.")
         return self.transaction_count
-    
+
     def get_coinbase_transaction(self) -> Transaction:
         """
         Retrieves the coinbase transaction from the block, which is the first transaction in the block and contains the block reward.
@@ -487,14 +501,14 @@ def get_block_reward(self) -> int:
         if self.transactions is None:
             raise ValueError("No transactions given.")
         coinbase = self.get_coinbase_transaction()
-        
+
         amount = 0
 
-        for output in coinbase.outputs :
+        for output in coinbase.outputs:
             amount += output.amount
 
         return amount
-    
+
     def get_witness_transactions(self) -> list[Transaction]:
         """
         Returns a list of transactions that contain SegWit data.
@@ -506,10 +520,10 @@ def get_witness_transactions(self) -> list[Transaction]:
         """
         if self.transactions is None:
             raise ValueError("No transactions given.")
-        
+
         witness_transactions = [tx for tx in self.transactions if tx.has_segwit]
         return witness_transactions
-    
+
     def get_legacy_transactions(self) -> list[Transaction]:
         """
         Returns a list of legacy transactions.
@@ -521,6 +535,6 @@ def get_legacy_transactions(self) -> list[Transaction]:
         """
         if self.transactions is None:
             raise ValueError("No transactions given.")
-        
+
         legacy_transactions = [tx for tx in self.transactions if not tx.has_segwit]
-        return legacy_transactions
+        return legacy_transactions
