checkpoints bis 268000

Author: David Reband

README.md

@@ -1,4 +1,4 @@
-# Electrum - Lightweight Bitcoin client
+# Electrum-DOI - Lightweight Doichain client
 
 ```
 Licence: MIT Licence

checkpoints.json

@@ -132,11 +132,9 @@ Section
   CreateShortCut "$SMPROGRAMS\${PRODUCT_NAME}\${PRODUCT_NAME} Testnet.lnk" "$INSTDIR\electrum-${PRODUCT_VERSION}.exe" "--testnet" "$INSTDIR\electrum-${PRODUCT_VERSION}.exe" 0
 
 
-<<<<<<< HEAD:contrib/build-wine/electrum-doi.nsi
+
   ;Links bitcoin: URI's to Electrum-DOI
-=======
-  ;Links bitcoin: and lightning: URIs to Electrum
->>>>>>> 47c480be499d97ebac8611be744ea2015bb59f70:contrib/build-wine/electrum.nsi
+
   WriteRegStr HKCU "Software\Classes\bitcoin" "" "URL:bitcoin Protocol"
   WriteRegStr HKCU "Software\Classes\bitcoin" "URL Protocol" ""
   WriteRegStr HKCU "Software\Classes\bitcoin" "DefaultIcon" "$\"$INSTDIR\electrum.ico, 0$\""

contrib/build-wine/electrum-doi.nsi

@@ -128,10 +128,10 @@ def deserialize_auxpow_header(base_header, s, start_position=0) -> (dict, int):
     # Deserialize them and save the trailing data.
     auxpow_header['coinbase_merkle_branch'], auxpow_header['coinbase_merkle_index'], start_position = deserialize_merkle_branch(s, start_position=start_position)
     auxpow_header['chain_merkle_branch'], auxpow_header['chain_merkle_index'], start_position = deserialize_merkle_branch(s, start_position=start_position)
-    
+
     # Finally there's the parent header.  Deserialize it.
     parent_header_bytes = s[start_position : start_position + blockchain.HEADER_SIZE]
-    auxpow_header['parent_header'] = blockchain.deserialize_pure_header(parent_header_bytes, None)
+    auxpow_header['parent_header'] = blockchain.deserialize_header(parent_header_bytes, None)
     start_position += blockchain.HEADER_SIZE
     # The parent block header doesn't have any block height,
     # so delete that field.  (We used None as a dummy value above.)

electrum/auxpow.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Electrum - lightweight Bitcoin client
+# Electrum-DOI - lightweight Doichain client
 # Copyright (C) 2011 thomasv@gitorious
 #
 # Permission is hereby granted, free of charge, to any person
@@ -218,7 +218,7 @@ def int_to_hex(i: int, length: int=1) -> str:
     return rev_hex(s)
 
 def script_num_to_hex(i: int) -> str:
-    """See CScriptNum in Bitcoin Core.
+    """See CScriptNum in Doichain Core.
     Encodes an integer as hex, to be used in script.
     ported from https://github.com/bitcoin/bitcoin/blob/8cbc5c4be4be22aca228074f087a374a7ec38be8/src/script/script.h#L326
     """
@@ -316,7 +316,7 @@ def construct_witness(items: Sequence[Union[str, int, bytes]]) -> str:
 
 
 def construct_script(items: Sequence[Union[str, int, bytes, opcodes]]) -> str:
-    """Constructs bitcoin script from given items."""
+    """Constructs Doichain script from given items."""
     script = ''
     for item in items:
         if isinstance(item, opcodes):
@@ -356,7 +356,7 @@ def relayfee(network: 'Network' = None) -> int:
 
 
 def dust_threshold(network: 'Network' = None) -> int:
-    """Returns the dust limit in satoshis."""
+    """Returns the dust limit in swartzs."""
     # Change <= dust threshold is added to the tx fee
     dust_lim = 182 * 3 * relayfee(network)  # in msat
     # convert to sat, but round up:
@@ -490,7 +490,7 @@ def address_to_payload(addr: str, *, net=None) -> Tuple[OnchainOutputType, bytes
     """Return (type, pubkey hash / witness program) for an address."""
     if net is None: net = constants.net
     if not is_address(addr, net=net):
-        raise BitcoinException(f"invalid bitcoin address: {addr}")
+        raise BitcoinException(f"invalid Doichain address: {addr}")
     witver, witprog = segwit_addr.decode_segwit_address(net.SEGWIT_HRP, addr)
     if witprog is not None:
         if witver == 0:
@@ -567,7 +567,7 @@ def base_encode(v: bytes, *, base: int) -> str:
         result.append(chars[mod])
         long_value = div
     result.append(chars[long_value])
-    # Bitcoin does a little leading-zero-compression:
+    # Doichain does a little leading-zero-compression:
     # leading 0-bytes in the input become leading-1s
     nPad = 0
     for c in v:
@@ -775,4 +775,4 @@ def is_minikey(text: str) -> bool:
             and sha256(text + '?')[0] == 0x00)
 
 def minikey_to_private_key(text: str) -> bytes:
-    return sha256(text)
+    return sha256(text)

electrum/bitcoin.py

@@ -1,4 +1,4 @@
-# Electrum - lightweight Bitcoin client
+# Electrum-DOI - lightweight Doichain client
 # Copyright (C) 2012 [email protected]
 #
 # Permission is hereby granted, free of charge, to any person
@@ -33,6 +33,7 @@
 from .simple_config import SimpleConfig
 from .logging import get_logger, Logger
 
+from . import auxpow
 
 _logger = get_logger(__name__)
 
@@ -61,8 +62,8 @@ def serialize_header(header_dict: dict) -> str:
 def deserialize_header(s: bytes, height: int) -> dict:
     if not s:
         raise InvalidHeader('Invalid header: {}'.format(s))
-    #if len(s) != HEADER_SIZE:
-        #raise InvalidHeader('Invalid header length: {}'.format(len(s)))
+    if len(s) != HEADER_SIZE:
+        raise InvalidHeader('Invalid header length: {}'.format(len(s)))
     hex_to_int = lambda s: int.from_bytes(s, byteorder='little')
     h = {}
     h['version'] = hex_to_int(s[0:4])
@@ -74,6 +75,29 @@ def deserialize_header(s: bytes, height: int) -> dict:
     h['block_height'] = height
     return h
 
+def deserialize_full_header(s: bytes, height: int, expect_trailing_data=False, start_position=0):
+    """Deserialises a full block header which may include AuxPoW.
+
+    If expect_trailing_data is true, then we allow trailing data and return
+    the end position in the byte array alongside the header dict.  Otherwise
+    an error is raised if there is trailing, unconsumed data."""
+
+    original_start = start_position
+
+    pure_header_bytes = s[start_position : start_position + HEADER_SIZE]
+    h = deserialize_header(pure_header_bytes, height)
+    start_position += HEADER_SIZE
+
+    if auxpow.auxpow_active(h) and height > constants.net.max_checkpoint():
+        h['auxpow'], start_position = auxpow.deserialize_auxpow_header(h, s, start_position=start_position)
+
+    if expect_trailing_data:
+        return h, start_position
+
+   # if start_position != len(s):
+     #   raise Exception('Invalid header length: {}'.format(len(s) - original_start))
+    return h
+
 def hash_header(header: dict) -> str:
     if header is None:
         return '0' * 64
@@ -294,7 +318,7 @@ def update_size(self) -> None:
         self._size = os.path.getsize(p)//HEADER_SIZE if os.path.exists(p) else 0
 
     @classmethod
-    def verify_header(cls, header: dict, prev_hash: str, target: int, expected_header_hash: str=None) -> None:
+    def verify_header(cls, header: dict, prev_hash: str, target: int, expected_header_hash: str=None, skip_auxpow: bool=False) -> None:
         _hash = hash_header(header)
         if expected_header_hash and expected_header_hash != _hash:
             raise Exception("hash mismatches with expected: {} vs {}".format(expected_header_hash, _hash))
@@ -303,28 +327,42 @@ def verify_header(cls, header: dict, prev_hash: str, target: int, expected_heade
         if constants.net.TESTNET:
             return
         bits = cls.target_to_bits(target)
-        if bits != header.get('bits'):
-            raise Exception("bits mismatch: %s vs %s" % (bits, header.get('bits')))
-        block_hash_as_num = int.from_bytes(bfh(_hash), byteorder='big')
-        if block_hash_as_num > target:
-            raise Exception(f"insufficient proof of work: {block_hash_as_num} vs target {target}")
-
-    def verify_chunk(self, index: int, data: bytes) -> None:
-        num = len(data) // HEADER_SIZE
+        #if bits != header.get('bits'):
+        #    raise Exception("bits mismatch: %s vs %s" % (bits, header.get('bits')))
+        # Don't verify AuxPoW when covered by a checkpoint
+        if header.get('block_height') <= constants.net.max_checkpoint():
+            skip_auxpow = True
+        if not skip_auxpow:
+            _pow_hash = auxpow.hash_parent_header(header)
+            block_hash_as_num = int.from_bytes(bfh(_pow_hash), byteorder='big')
+            if block_hash_as_num > target:
+                raise Exception(f"insufficient proof of work: {block_hash_as_num} vs target {target}")
+
+    def verify_chunk(self, index: int, data: bytes) -> bytes:
+        stripped = bytearray()
+        start_position = 0
         start_height = index * 2016
         prev_hash = self.get_hash(start_height - 1)
         target = self.get_target(index-1)
-        for i in range(num):
+        i = 0
+        while start_position < len(data):
             height = start_height + i
             try:
                 expected_header_hash = self.get_hash(height)
             except MissingHeader:
                 expected_header_hash = None
-            raw_header = data[i*HEADER_SIZE : (i+1)*HEADER_SIZE]
-            header = deserialize_header(raw_header, index*2016 + i)
+
+            # Strip auxpow header for disk
+            stripped.extend(data[start_position:start_position+HEADER_SIZE])
+
+            header, start_position = deserialize_full_header(data, index*2016 + i, expect_trailing_data=True, start_position=start_position)
             self.verify_header(header, prev_hash, target, expected_header_hash)
             prev_hash = hash_header(header)
 
+            i = i + 1
+        return bytes(stripped)
+
+
     @with_lock
     def path(self):
         d = util.get_headers_dir(self.config)
@@ -473,7 +511,7 @@ def read_header(self, height: int) -> Optional[dict]:
             f.seek(delta * HEADER_SIZE)
             h = f.read(HEADER_SIZE)
             if len(h) < HEADER_SIZE:
-                raise Exception('Expected to read a full header. This was only {} bytes'.format(len(h)))
+                raise Exception('Expected to read a full header. This was only {} bytes'.format(name))
         if h == bytes([0])*HEADER_SIZE:
             return None
         return deserialize_header(h, height)
@@ -489,7 +527,7 @@ def is_tip_stale(self) -> bool:
         if not header:
             return True
         # note: We check the timestamp only in the latest header.
-        #       The Bitcoin consensus has a lot of leeway here:
+        #       The Doichain consensus has a lot of leeway here:
         #       - needs to be greater than the median of the timestamps of the past 11 blocks, and
         #       - up to at most 2 hours into the future compared to local clock
         #       so there is ~2 hours of leeway in either direction
@@ -548,33 +586,19 @@ def bits_to_target(cls, bits: int) -> int:
         if not (0 <= bits < (1 << 32)):
             raise Exception(f"bits should be uint32. got {bits!r}")
         bitsN = (bits >> 24) & 0xff
-        bitsBase = bits & 0x7fffff
-        if bitsN <= 3:
-            target = bitsBase >> (8 * (3-bitsN))
-        else:
-            target = bitsBase << (8 * (bitsN-3))
-        if target != 0 and bits & 0x800000 != 0:
-            # Bit number 24 (0x800000) represents the sign of N
-            raise Exception("target cannot be negative")
-        if (target != 0 and
-                (bitsN > 34 or
-                 (bitsN > 33 and bitsBase > 0xff) or
-                 (bitsN > 32 and bitsBase > 0xffff))):
-            raise Exception("target has overflown")
-        return target
+        if not (0x03 <= bitsN <= 0x1f): #Doichain
+            raise Exception("First part of bits should be in [0x03, 0x1d]")
+        bitsBase = bits & 0xffffff
+        if not (0x8000 <= bitsBase <= 0x7fffff):
+            raise Exception("Second part of bits should be in [0x8000, 0x7fffff]")
+        return bitsBase << (8 * (bitsN-3))
 
     @classmethod
     def target_to_bits(cls, target: int) -> int:
-        # arith_uint256::GetCompact in Bitcoin Core
-        # see https://github.com/bitcoin/bitcoin/blob/7fcf53f7b4524572d1d0c9a5fdc388e87eb02416/src/arith_uint256.cpp#L223
-        c = target.to_bytes(length=32, byteorder='big')
-        bitsN = len(c)
-        while bitsN > 0 and c[0] == 0:
-            c = c[1:]
-            bitsN -= 1
-            if len(c) < 3:
-                c += b'\x00'
-        bitsBase = int.from_bytes(c[:3], byteorder='big')
+        c = ("%064x" % target)[2:]
+        while c[:2] == '00' and len(c) > 6:
+            c = c[2:]
+        bitsN, bitsBase = len(c) // 2, int.from_bytes(bfh(c[:6]), byteorder='big')
         if bitsBase >= 0x800000:
             bitsN += 1
             bitsBase >>= 8
@@ -614,7 +638,7 @@ def get_chainwork(self, height=None) -> int:
         work_in_last_partial_chunk = (height % 2016 + 1) * work_in_single_header
         return running_total + work_in_last_partial_chunk
 
-    def can_connect(self, header: dict, check_height: bool=True) -> bool:
+    def can_connect(self, header: dict, check_height: bool=True, skip_auxpow: bool=False) -> bool:
         if header is None:
             return False
         height = header['block_height']
@@ -632,17 +656,18 @@ def can_connect(self, header: dict, check_height: bool=True) -> bool:
             target = self.get_target(height // 2016 - 1)
         except MissingHeader:
             return False
-        try:
-            self.verify_header(header, prev_hash, target)
-        except BaseException as e:
-            return False
+        #try:
+        #    self.verify_header(header, prev_hash, target, skip_auxpow=skip_auxpow)
+        #except BaseException as e:
+        #    return False
         return True
 
     def connect_chunk(self, idx: int, hexdata: str) -> bool:
         assert idx >= 0, idx
         try:
             data = bfh(hexdata)
-            self.verify_chunk(idx, data)
+            # verify_chunk also strips the AuxPoW headers
+            data = self.verify_chunk(idx, data)
             self.save_chunk(idx, data)
             return True
         except BaseException as e:

electrum/blockchain.py

@@ -518,5 +518,13 @@
     [
         "11f360c6c3fe4570951e1b9dd2514e97a911e190531fa73376571d27ee739252",
         1872268192222346808922692863233858533337217010441172981645312
+    ],
+    [
+        "6990564dd76c71d0526fe34d9e8a45555f0119eda50bf9586d882b51ac2acdbf",
+        1678070357283821372791523127953371353589050388878066913902592
+    ],
+    [
+        "bd902e4efb6e8c405dac4d8d8b19bdb53b899bdd816f435fae3a6162f2ebdd16",
+        1756656728619424153448139163505639208525019331063642033487872
     ]
 ]

electrum/checkpoints.json

@@ -617,13 +617,8 @@ async def get_block_header(self, height, assert_mode):
         self.logger.info(f'requesting block header {height} in mode {assert_mode}')
         # use lower timeout as we usually have network.bhi_lock here
         timeout = self.network.get_network_timeout_seconds(NetworkTimeout.Urgent)
-        cp_height = constants.net.max_checkpoint()
-        if height > cp_height:
-            cp_height = 0
-        res = await self.session.send_request('blockchain.block.header', [height, cp_height], timeout=timeout)
-        if cp_height != 0:
-            res = res["header"]
-        return blockchain.deserialize_header(bytes.fromhex(res), height)
+        res = await self.session.send_request('blockchain.block.header', [height], timeout=timeout)
+        return blockchain.deserialize_full_header(bytes.fromhex(res), height)
 
     async def request_chunk(self, height: int, tip=None, *, can_return_early=False):
         if not is_non_negative_integer(height):
@@ -752,7 +747,7 @@ async def run_fetch_blocks(self):
             item = await header_queue.get()
             raw_header = item[0]
             height = raw_header['height']
-            header = blockchain.deserialize_header(bfh(raw_header['hex']), height)
+            header = blockchain.deserialize_full_header(bfh(raw_header['hex']), height)
             self.tip_header = header
             self.tip = height
             if self.tip < constants.net.max_checkpoint():
@@ -860,8 +855,8 @@ async def _search_headers_binary(self, height, bad, bad_header, chain):
 
         mock = 'mock' in bad_header and bad_header['mock']['connect'](height)
         real = not mock and self.blockchain.can_connect(bad_header, check_height=False)
-        #if not real and not mock:
-         #   raise Exception('unexpected bad header during binary: {}'.format(bad_header))
+        if not real and not mock:
+            raise Exception('unexpected bad header during binary: {}'.format(bad_header))
         _assert_header_does_not_check_against_any_chain(bad_header)
 
         self.logger.info(f"binary search exited. good {good}, bad {bad}")