chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7__py3-none-any.whl

chia/full_node/full_node_api.py

@@ -30,6 +30,7 @@ from chia_rs import (
     additions_and_removals,
     get_flags_for_height_and_constants,
 )
+from chia_rs import get_puzzle_and_solution_for_coin2 as get_puzzle_and_solution_for_coin
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 from chiabip158 import PyBIP158
@@ -43,7 +44,6 @@ from chia.consensus.signage_point import SignagePoint
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.fee_estimator_interface import FeeEstimatorInterface
 from chia.full_node.full_block_utils import get_height_and_tx_status_from_block, header_block_from_block
-from chia.full_node.mempool_check_conditions import get_puzzle_and_solution_for_coin
 from chia.full_node.tx_processing_queue import TransactionQueueEntry, TransactionQueueFull
 from chia.protocols import farmer_protocol, full_node_protocol, introducer_protocol, timelord_protocol, wallet_protocol
 from chia.protocols.fee_estimate import FeeEstimate, FeeEstimateGroup, fee_rate_v2_to_v1
@@ -72,6 +72,7 @@ from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.peer_info import PeerInfo
 from chia.util.batches import to_batches
 from chia.util.db_wrapper import SQLITE_MAX_VARIABLE_NUMBER
+from chia.util.errors import Err, ValidationError
 from chia.util.hash import std_hash
 from chia.util.limited_semaphore import LimitedSemaphoreFullError
 from chia.util.task_referencer import create_referenced_task
@@ -1001,14 +1002,14 @@ class FullNodeAPI:
             )
 
             # The block's timestamp must be greater than the previous transaction block's timestamp
-            timestamp = uint64(int(time.time()))
+            timestamp = uint64(time.time())
             curr: Optional[BlockRecord] = prev_b
             while curr is not None and not curr.is_transaction_block and curr.height != 0:
                 curr = self.full_node.blockchain.try_block_record(curr.prev_hash)
             if curr is not None:
                 assert curr.timestamp is not None
                 if timestamp <= curr.timestamp:
-                    timestamp = uint64(int(curr.timestamp + 1))
+                    timestamp = uint64(curr.timestamp + 1)
 
             self.log.info("Starting to make the unfinished block")
             unfinished_block: UnfinishedBlock = create_unfinished_block(
@@ -1133,6 +1134,12 @@ class FullNodeAPI:
         try:
             await self.full_node.add_unfinished_block(new_candidate, None, True)
         except Exception as e:
+            if isinstance(e, ValidationError) and e.code == Err.NO_OVERFLOWS_IN_FIRST_SUB_SLOT_NEW_EPOCH:
+                self.full_node.log.info(
+                    f"Failed to farm block {e}. Consensus rules prevent this block from being farmed. Not retrying"
+                )
+                return None
+
             # If we have an error with this block, try making an empty block
             self.full_node.log.error(f"Error farming block {e} {new_candidate}")
             candidate_tuple = self.full_node.full_node_store.get_candidate_block(
@@ -1393,14 +1400,11 @@ class FullNodeAPI:
             error_name = error.name if error is not None else None
             if status == MempoolInclusionStatus.SUCCESS:
                 response = wallet_protocol.TransactionAck(spend_name, uint8(status.value), error_name)
+            # If it failed/pending, but it previously succeeded (in mempool), this is idempotence, return SUCCESS
+            elif self.full_node.mempool_manager.get_spendbundle(spend_name) is not None:
+                response = wallet_protocol.TransactionAck(spend_name, uint8(MempoolInclusionStatus.SUCCESS.value), None)
             else:
-                # If it failed/pending, but it previously succeeded (in mempool), this is idempotence, return SUCCESS
-                if self.full_node.mempool_manager.get_spendbundle(spend_name) is not None:
-                    response = wallet_protocol.TransactionAck(
-                        spend_name, uint8(MempoolInclusionStatus.SUCCESS.value), None
-                    )
-                else:
-                    response = wallet_protocol.TransactionAck(spend_name, uint8(status.value), error_name)
+                response = wallet_protocol.TransactionAck(spend_name, uint8(status.value), error_name)
         return make_msg(ProtocolMessageTypes.transaction_ack, response)
 
     @metadata.request()
@@ -1427,17 +1431,18 @@ class FullNodeAPI:
         )
         assert block_generator is not None
         try:
-            spend_info = await asyncio.get_running_loop().run_in_executor(
+            puzzle, solution = await asyncio.get_running_loop().run_in_executor(
                 self.executor,
                 get_puzzle_and_solution_for_coin,
-                block_generator,
+                block_generator.program,
+                block_generator.generator_refs,
+                self.full_node.constants.MAX_BLOCK_COST_CLVM,
                 coin_record.coin,
-                height,
-                self.full_node.constants,
+                get_flags_for_height_and_constants(height, self.full_node.constants),
             )
         except ValueError:
             return reject_msg
-        wrapper = PuzzleSolutionResponse(coin_name, height, spend_info.puzzle, spend_info.solution)
+        wrapper = PuzzleSolutionResponse(coin_name, height, puzzle, solution)
         response = wallet_protocol.RespondPuzzleSolution(wrapper)
         response_msg = make_msg(ProtocolMessageTypes.respond_puzzle_solution, response)
         return response_msg
@@ -1452,24 +1457,13 @@ class FullNodeAPI:
 
         if request.end_height < request.start_height or request.end_height - request.start_height > 128:
             return make_msg(ProtocolMessageTypes.reject_block_headers, reject)
-        if self.full_node.block_store.db_wrapper.db_version == 2:
-            try:
-                blocks_bytes = await self.full_node.block_store.get_block_bytes_in_range(
-                    request.start_height, request.end_height
-                )
-            except ValueError:
-                return make_msg(ProtocolMessageTypes.reject_block_headers, reject)
-
-        else:
-            height_to_hash = self.full_node.blockchain.height_to_hash
-            header_hashes: list[bytes32] = []
-            for i in range(request.start_height, request.end_height + 1):
-                header_hash: Optional[bytes32] = height_to_hash(uint32(i))
-                if header_hash is None:
-                    return make_msg(ProtocolMessageTypes.reject_header_blocks, reject)
-                header_hashes.append(header_hash)
+        try:
+            blocks_bytes = await self.full_node.block_store.get_block_bytes_in_range(
+                request.start_height, request.end_height
+            )
+        except ValueError:
+            return make_msg(ProtocolMessageTypes.reject_block_headers, reject)
 
-            blocks_bytes = await self.full_node.block_store.get_block_bytes_by_hash(header_hashes)
         if len(blocks_bytes) != (request.end_height - request.start_height + 1):  # +1 because interval is inclusive
             return make_msg(ProtocolMessageTypes.reject_block_headers, reject)
         return_filter = request.return_filter

chia/full_node/full_node_rpc_api.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import time
+from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
@@ -13,8 +14,12 @@ from chia_rs import (
     PlotSize,
     SpendBundle,
     SpendBundleConditions,
+    get_flags_for_height_and_constants,
+    get_spends_for_trusted_block,
+    get_spends_for_trusted_block_with_conditions,
     run_block_generator2,
 )
+from chia_rs import get_puzzle_and_solution_for_coin2 as get_puzzle_and_solution_for_coin
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64, uint128
 
@@ -23,11 +28,6 @@ from chia.consensus.get_block_generator import get_block_generator
 from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR
 from chia.full_node.fee_estimator_interface import FeeEstimatorInterface
 from chia.full_node.full_node import FullNode
-from chia.full_node.mempool_check_conditions import (
-    get_puzzle_and_solution_for_coin,
-    get_spends_for_block,
-    get_spends_for_block_with_conditions,
-)
 from chia.protocols.outbound_message import NodeType
 from chia.rpc.rpc_server import Endpoint, EndpointResult
 from chia.types.blockchain_format.proof_of_space import calculate_prefix_bits
@@ -90,6 +90,8 @@ async def get_average_block_time(
 
 
 class FullNodeRpcApi:
+    executor: ThreadPoolExecutor
+
     if TYPE_CHECKING:
         from chia.rpc.rpc_server import RpcApiProtocol
 
@@ -99,6 +101,7 @@ class FullNodeRpcApi:
         self.service = service
         self.service_name = "chia_full_node"
         self.cached_blockchain_state: Optional[dict[str, Any]] = None
+        self.executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="node-rpc-")
 
     def get_routes(self) -> dict[str, Endpoint]:
         return {
@@ -482,14 +485,21 @@ class FullNodeRpcApi:
         if full_block is None:
             raise ValueError(f"Block {header_hash.hex()} not found")
 
-        spends: list[CoinSpend] = []
         block_generator = await get_block_generator(self.service.blockchain.lookup_block_generators, full_block)
         if block_generator is None:  # if block is not a transaction block.
-            return {"block_spends": spends}
-
-        spends = get_spends_for_block(block_generator, full_block.height, self.service.constants)
+            return {"block_spends": []}
+
+        flags = get_flags_for_height_and_constants(full_block.height, self.service.constants)
+        spends = await asyncio.get_running_loop().run_in_executor(
+            self.executor,
+            get_spends_for_trusted_block,
+            self.service.constants,
+            block_generator.program,
+            block_generator.generator_refs,
+            flags,
+        )
 
-        return {"block_spends": spends}
+        return spends
 
     async def get_block_spends_with_conditions(self, request: dict[str, Any]) -> EndpointResult:
         if "header_hash" not in request:
@@ -503,28 +513,22 @@ class FullNodeRpcApi:
         if block_generator is None:  # if block is not a transaction block.
             return {"block_spends_with_conditions": []}
 
-        spends_with_conditions = get_spends_for_block_with_conditions(
-            block_generator, full_block.height, self.service.constants
+        flags = get_flags_for_height_and_constants(full_block.height, self.service.constants)
+        spends_with_conditions = await asyncio.get_running_loop().run_in_executor(
+            self.executor,
+            get_spends_for_trusted_block_with_conditions,
+            self.service.constants,
+            block_generator.program,
+            block_generator.generator_refs,
+            flags,
         )
-
-        return {
-            "block_spends_with_conditions": [
-                {
-                    "coin_spend": spend_with_conditions.coin_spend,
-                    "conditions": [
-                        {"opcode": condition.opcode, "vars": [var.hex() for var in condition.vars]}
-                        for condition in spend_with_conditions.conditions
-                    ],
-                }
-                for spend_with_conditions in spends_with_conditions
-            ]
-        }
+        return {"block_spends_with_conditions": spends_with_conditions}
 
     async def get_block_record_by_height(self, request: dict[str, Any]) -> EndpointResult:
         if "height" not in request:
             raise ValueError("No height in request")
         height = request["height"]
-        header_height = uint32(int(height))
+        header_height = uint32(height)
         peak_height = self.service.blockchain.get_peak_height()
         if peak_height is None or header_height > peak_height:
             raise ValueError(f"Block height {height} not found in chain")
@@ -613,7 +617,7 @@ class FullNodeRpcApi:
             * additional_difficulty_constant
             * eligible_plots_filter_multiplier
         )
-        return {"space": uint128(int(network_space_bytes_estimate))}
+        return {"space": uint128(network_space_bytes_estimate)}
 
     async def get_coin_records_by_puzzle_hash(self, request: dict[str, Any]) -> EndpointResult:
         """
@@ -787,10 +791,17 @@ class FullNodeRpcApi:
         )
         assert block_generator is not None
 
-        spend_info = get_puzzle_and_solution_for_coin(
-            block_generator, coin_record.coin, block.height, self.service.constants
-        )
-        return {"coin_solution": CoinSpend(coin_record.coin, spend_info.puzzle, spend_info.solution)}
+        try:
+            puzzle, solution = get_puzzle_and_solution_for_coin(
+                block_generator.program,
+                block_generator.generator_refs,
+                self.service.constants.MAX_BLOCK_COST_CLVM,
+                coin_record.coin,
+                get_flags_for_height_and_constants(block.height, self.service.constants),
+            )
+            return {"coin_solution": CoinSpend(coin_record.coin, puzzle, solution)}
+        except Exception as e:
+            raise ValueError(f"Failed to get puzzle and solution for coin {coin_record.coin}, error: {e}") from e
 
     async def get_additions_and_removals(self, request: dict[str, Any]) -> EndpointResult:
         if "header_hash" not in request:
@@ -884,7 +895,7 @@ class FullNodeRpcApi:
             if maybe_gen is not None:
                 # this also validates the signature
                 err, conds = await asyncio.get_running_loop().run_in_executor(
-                    self.service.blockchain.pool,
+                    self.executor,
                     run_block_generator2,
                     bytes(gen.program),
                     gen.generator_refs,
@@ -987,7 +998,7 @@ class FullNodeRpcApi:
 
         if peak is None:
             peak_height = uint32(0)
-            last_peak_timestamp = uint64(0)
+            last_peak_timestamp: Optional[uint64] = uint64(0)
             last_block_cost = 0
             fee_rate_last_block = 0.0
             last_tx_block_fees = uint64(0)

chia/full_node/full_node_rpc_client.py

@@ -7,10 +7,13 @@ from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
 from chia.consensus.signage_point import SignagePoint
-from chia.rpc.rpc_client import RpcClient
+from chia.rpc.rpc_client import ResponseFailureError, RpcClient
 from chia.types.coin_record import CoinRecord
 from chia.types.coin_spend import CoinSpendWithConditions
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.types.condition_with_args import ConditionWithArgs
 from chia.types.unfinished_header_block import UnfinishedHeaderBlock
+from chia.util.byte_types import hexstr_to_bytes
 
 
 def coin_record_dict_backwards_compat(coin_record: dict[str, Any]) -> dict[str, Any]:
@@ -33,11 +36,8 @@ class FullNodeRpcClient(RpcClient):
             response["blockchain_state"]["peak"] = BlockRecord.from_json_dict(response["blockchain_state"]["peak"])
         return cast(dict[str, Any], response["blockchain_state"])
 
-    async def get_block(self, header_hash: bytes32) -> Optional[FullBlock]:
-        try:
-            response = await self.fetch("get_block", {"header_hash": header_hash.hex()})
-        except Exception:
-            return None
+    async def get_block(self, header_hash: bytes32) -> FullBlock:
+        response = await self.fetch("get_block", {"header_hash": header_hash.hex()})
         return FullBlock.from_json_dict(response["block"])
 
     async def get_blocks(self, start: int, end: int, exclude_reorged: bool = False) -> list[FullBlock]:
@@ -49,16 +49,15 @@ class FullNodeRpcClient(RpcClient):
     async def get_block_record_by_height(self, height: int) -> Optional[BlockRecord]:
         try:
             response = await self.fetch("get_block_record_by_height", {"height": height})
-        except Exception:
-            return None
+        except ResponseFailureError as e:  # Block Height not found
+            if e.response["error"] == f"Block height {height} not found in chain":
+                return None
+            raise e
         return BlockRecord.from_json_dict(response["block_record"])
 
     async def get_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
-        try:
-            response = await self.fetch("get_block_record", {"header_hash": header_hash.hex()})
-            if response["block_record"] is None:
-                return None
-        except Exception:
+        response = await self.fetch("get_block_record", {"header_hash": header_hash.hex()})
+        if response["block_record"] is None:
             return None
         return BlockRecord.from_json_dict(response["block_record"])
 
@@ -81,12 +80,8 @@ class FullNodeRpcClient(RpcClient):
 
         return cast(int, network_space_bytes_estimate["space"])
 
-    async def get_coin_record_by_name(self, coin_id: bytes32) -> Optional[CoinRecord]:
-        try:
-            response = await self.fetch("get_coin_record_by_name", {"name": coin_id.hex()})
-        except Exception:
-            return None
-
+    async def get_coin_record_by_name(self, coin_id: bytes32) -> CoinRecord:
+        response = await self.fetch("get_coin_record_by_name", {"name": coin_id.hex()})
         return CoinRecord.from_json_dict(coin_record_dict_backwards_compat(response["coin_record"]))
 
     async def get_coin_records_by_names(
@@ -177,10 +172,7 @@ class FullNodeRpcClient(RpcClient):
         return [CoinRecord.from_json_dict(coin_record_dict_backwards_compat(coin)) for coin in response["coin_records"]]
 
     async def get_additions_and_removals(self, header_hash: bytes32) -> tuple[list[CoinRecord], list[CoinRecord]]:
-        try:
-            response = await self.fetch("get_additions_and_removals", {"header_hash": header_hash.hex()})
-        except Exception:
-            return [], []
+        response = await self.fetch("get_additions_and_removals", {"header_hash": header_hash.hex()})
         removals = []
         additions = []
         for coin_record in response["removals"]:
@@ -192,43 +184,43 @@ class FullNodeRpcClient(RpcClient):
     async def get_block_records(self, start: int, end: int) -> list[dict[str, Any]]:
         try:
             response = await self.fetch("get_block_records", {"start": start, "end": end})
-            if response["block_records"] is None:
+        except ResponseFailureError as e:  # No Peak Yet
+            if e.response["error"] == "Peak is None":
                 return []
-        except Exception:
+            raise e
+        if response["block_records"] is None:
             return []
         # TODO: return block records
         return cast(list[dict[str, Any]], response["block_records"])
 
-    async def get_block_spends(self, header_hash: bytes32) -> Optional[list[CoinSpend]]:
-        try:
-            response = await self.fetch("get_block_spends", {"header_hash": header_hash.hex()})
-            block_spends = []
-            for block_spend in response["block_spends"]:
-                block_spends.append(CoinSpend.from_json_dict(block_spend))
-            return block_spends
-        except Exception:
-            return None
-
-    async def get_block_spends_with_conditions(self, header_hash: bytes32) -> Optional[list[CoinSpendWithConditions]]:
-        try:
-            response = await self.fetch("get_block_spends_with_conditions", {"header_hash": header_hash.hex()})
-            block_spends: list[CoinSpendWithConditions] = []
-            for block_spend in response["block_spends_with_conditions"]:
-                block_spends.append(CoinSpendWithConditions.from_json_dict(block_spend))
-            return block_spends
-
-        except Exception:
-            return None
+    async def get_block_spends(self, header_hash: bytes32) -> list[CoinSpend]:
+        response = await self.fetch("get_block_spends", {"header_hash": header_hash.hex()})
+        output = []
+        for block_spend in response["block_spends"]:
+            output.append(CoinSpend.from_json_dict(block_spend))
+        return output
+
+    async def get_block_spends_with_conditions(self, header_hash: bytes32) -> list[CoinSpendWithConditions]:
+        response = await self.fetch("get_block_spends_with_conditions", {"header_hash": header_hash.hex()})
+        block_spends: list[CoinSpendWithConditions] = []
+        for block_spend in response["block_spends_with_conditions"]:
+            coin_spend = CoinSpend.from_json_dict(block_spend["coin_spend"])
+            cond_tuples = block_spend["conditions"]
+            conditions = []
+            for condition in cond_tuples:
+                cwa = ConditionWithArgs(
+                    opcode=ConditionOpcode(bytes([condition[0]])), vars=[hexstr_to_bytes(b) for b in condition[1]]
+                )
+                conditions.append(cwa)
+            block_spends.append(CoinSpendWithConditions(coin_spend=coin_spend, conditions=conditions))
+        return block_spends
 
     async def push_tx(self, spend_bundle: SpendBundle) -> dict[str, Any]:
         return await self.fetch("push_tx", {"spend_bundle": spend_bundle.to_json_dict()})
 
-    async def get_puzzle_and_solution(self, coin_id: bytes32, height: uint32) -> Optional[CoinSpend]:
-        try:
-            response = await self.fetch("get_puzzle_and_solution", {"coin_id": coin_id.hex(), "height": height})
-            return CoinSpend.from_json_dict(response["coin_solution"])
-        except Exception:
-            return None
+    async def get_puzzle_and_solution(self, coin_id: bytes32, height: uint32) -> CoinSpend:
+        response = await self.fetch("get_puzzle_and_solution", {"coin_id": coin_id.hex(), "height": height})
+        return CoinSpend.from_json_dict(response["coin_solution"])
 
     async def get_all_mempool_tx_ids(self) -> list[bytes32]:
         response = await self.fetch("get_all_mempool_tx_ids", {})
@@ -245,14 +237,11 @@ class FullNodeRpcClient(RpcClient):
         self,
         tx_id: bytes32,
         include_pending: bool = False,
-    ) -> Optional[dict[str, Any]]:
-        try:
-            response = await self.fetch(
-                "get_mempool_item_by_tx_id", {"tx_id": tx_id.hex(), "include_pending": include_pending}
-            )
-            return cast(dict[str, Any], response["mempool_item"])
-        except Exception:
-            return None
+    ) -> dict[str, Any]:
+        response = await self.fetch(
+            "get_mempool_item_by_tx_id", {"tx_id": tx_id.hex(), "include_pending": include_pending}
+        )
+        return cast(dict[str, Any], response["mempool_item"])
 
     async def get_mempool_items_by_coin_name(self, coin_name: bytes32) -> dict[str, Any]:
         response = await self.fetch("get_mempool_items_by_coin_name", {"coin_name": coin_name.hex()})
@@ -264,26 +253,25 @@ class FullNodeRpcClient(RpcClient):
 
     async def get_recent_signage_point_or_eos(
         self, sp_hash: Optional[bytes32], challenge_hash: Optional[bytes32]
-    ) -> Optional[Any]:
-        try:
-            if sp_hash is not None:
-                assert challenge_hash is None
-                response = await self.fetch("get_recent_signage_point_or_eos", {"sp_hash": sp_hash.hex()})
-                return {
-                    "signage_point": SignagePoint.from_json_dict(response["signage_point"]),
-                    "time_received": response["time_received"],
-                    "reverted": response["reverted"],
-                }
-            else:
-                assert challenge_hash is not None
-                response = await self.fetch("get_recent_signage_point_or_eos", {"challenge_hash": challenge_hash.hex()})
-                return {
-                    "eos": EndOfSubSlotBundle.from_json_dict(response["eos"]),
-                    "time_received": response["time_received"],
-                    "reverted": response["reverted"],
-                }
-        except Exception:
-            return None
+    ) -> dict[str, Any]:
+        if sp_hash is not None and challenge_hash is not None:
+            raise ValueError("Either sp_hash or challenge_hash must be provided, not both.")
+        elif sp_hash is not None:
+            response = await self.fetch("get_recent_signage_point_or_eos", {"sp_hash": sp_hash.hex()})
+            return {
+                "signage_point": SignagePoint.from_json_dict(response["signage_point"]),
+                "time_received": response["time_received"],
+                "reverted": response["reverted"],
+            }
+        elif challenge_hash is not None:
+            response = await self.fetch("get_recent_signage_point_or_eos", {"challenge_hash": challenge_hash.hex()})
+            return {
+                "eos": EndOfSubSlotBundle.from_json_dict(response["eos"]),
+                "time_received": response["time_received"],
+                "reverted": response["reverted"],
+            }
+        else:
+            raise ValueError("sp_hash or challenge_hash must be provided.")
 
     async def get_fee_estimate(
         self,

chia/full_node/full_node_service.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from chia.full_node.full_node import FullNode
+from chia.full_node.full_node_api import FullNodeAPI
+from chia.full_node.full_node_rpc_api import FullNodeRpcApi
+from chia.server.start_service import Service
+
+FullNodeService = Service[FullNode, FullNodeAPI, FullNodeRpcApi]

chia/full_node/full_node_store.py

@@ -833,10 +833,12 @@ class FullNodeStore:
         self, cc_signage_point: bytes32, challenge: bytes32, index: uint8
     ) -> Optional[SignagePoint]:
         assert len(self.finished_sub_slots) >= 1
-        if cc_signage_point == self.constants.GENESIS_CHALLENGE:
-            return SignagePoint(None, None, None, None)
         for sub_slot, sps, _ in self.finished_sub_slots:
-            if sub_slot is not None and sub_slot.challenge_chain.get_hash() == challenge:
+            if sub_slot is not None:
+                cc_hash = sub_slot.challenge_chain.get_hash()
+            else:
+                cc_hash = self.constants.GENESIS_CHALLENGE
+            if cc_hash == challenge:
                 if index == 0:
                     # first SP in the sub slot
                     return SignagePoint(None, None, None, None)