chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/full_node/full_node_rpc_api.py

@@ -4,14 +4,15 @@ import asyncio
 import time
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia_rs import (
     MEMPOOL_MODE,
     BlockRecord,
+    CoinRecord,
     CoinSpend,
     FullBlock,
-    PlotSize,
+    PlotParam,
     SpendBundle,
     SpendBundleConditions,
     get_flags_for_height_and_constants,
@@ -24,6 +25,7 @@ from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64, uint128
 
 from chia.consensus.blockchain import Blockchain, BlockchainMutexPriority
+from chia.consensus.get_block_challenge import pre_sp_tx_block_height
 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
@@ -31,7 +33,6 @@ from chia.full_node.full_node import FullNode
 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
-from chia.types.coin_record import CoinRecord
 from chia.types.generator_types import BlockGenerator, NewBlockGenerator
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.unfinished_header_block import UnfinishedHeaderBlock
@@ -65,7 +66,7 @@ async def get_average_block_time(
     blockchain: Blockchain,
     base_block: BlockRecord,
     height_distance: int,
-) -> Optional[uint32]:
+) -> uint32 | None:
     newer_block = await get_nearest_transaction_block(blockchain, base_block)
     if newer_block.height < 1:
         return None
@@ -100,7 +101,7 @@ class FullNodeRpcApi:
     def __init__(self, service: FullNode) -> None:
         self.service = service
         self.service_name = "chia_full_node"
-        self.cached_blockchain_state: Optional[dict[str, Any]] = None
+        self.cached_blockchain_state: dict[str, Any] | None = None
         self.executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="node-rpc-")
 
     def get_routes(self) -> dict[str, Endpoint]:
@@ -139,7 +140,7 @@ class FullNodeRpcApi:
             "/get_fee_estimate": self.get_fee_estimate,
         }
 
-    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: dict[str, Any] | None = None) -> list[WsRpcMessage]:
         if change_data is None:
             change_data = {}
 
@@ -203,7 +204,7 @@ class FullNodeRpcApi:
                 },
             }
             return res
-        peak: Optional[BlockRecord] = self.service.blockchain.get_peak()
+        peak: BlockRecord | None = self.service.blockchain.get_peak()
 
         if peak is not None and peak.height > 0:
             difficulty = uint64(peak.weight - self.service.blockchain.block_record(peak.prev_hash).weight)
@@ -214,7 +215,7 @@ class FullNodeRpcApi:
 
         sync_mode: bool = self.service.sync_store.get_sync_mode() or self.service.sync_store.get_long_sync()
 
-        sync_tip_height: Optional[uint32] = uint32(0)
+        sync_tip_height: uint32 | None = uint32(0)
         if sync_mode:
             target_peak = self.service.sync_store.target_peak
             if target_peak is not None:
@@ -230,7 +231,7 @@ class FullNodeRpcApi:
         else:
             sync_progress_height = uint32(0)
 
-        average_block_time: Optional[uint32] = None
+        average_block_time: uint32 | None = None
         if peak is not None and peak.height > 1:
             newer_block_hex = peak.header_hash.hex()
             # Average over the last day
@@ -309,7 +310,7 @@ class FullNodeRpcApi:
                 return {"eos": eos, "time_received": time_received, "reverted": False}
 
             # Otherwise we can backtrack from peak to find it in the blockchain
-            curr: Optional[BlockRecord] = self.service.blockchain.get_peak()
+            curr: BlockRecord | None = self.service.blockchain.get_peak()
             if curr is None:
                 raise ValueError("No blocks in the chain")
 
@@ -345,8 +346,8 @@ class FullNodeRpcApi:
 
         # Otherwise we can backtrack from peak to find it in the blockchain
         rc_challenge: bytes32 = sp.rc_vdf.challenge
-        next_b: Optional[BlockRecord] = None
-        curr_b_optional: Optional[BlockRecord] = self.service.blockchain.get_peak()
+        next_b: BlockRecord | None = None
+        curr_b_optional: BlockRecord | None = self.service.blockchain.get_peak()
         assert curr_b_optional is not None
         curr_b: BlockRecord = curr_b_optional
 
@@ -391,7 +392,7 @@ class FullNodeRpcApi:
             raise ValueError("No header_hash in request")
         header_hash = bytes32.from_hexstr(request["header_hash"])
 
-        block: Optional[FullBlock] = await self.service.block_store.get_full_block(header_hash)
+        block: FullBlock | None = await self.service.block_store.get_full_block(header_hash)
         if block is None:
             raise ValueError(f"Block {header_hash.hex()} not found")
 
@@ -464,10 +465,10 @@ class FullNodeRpcApi:
             if peak_height < uint32(a):
                 self.service.log.warning("requested block is higher than known peak ")
                 break
-            header_hash: Optional[bytes32] = self.service.blockchain.height_to_hash(uint32(a))
+            header_hash: bytes32 | None = self.service.blockchain.height_to_hash(uint32(a))
             if header_hash is None:
                 raise ValueError(f"Height not in blockchain: {a}")
-            record: Optional[BlockRecord] = self.service.blockchain.try_block_record(header_hash)
+            record: BlockRecord | None = self.service.blockchain.try_block_record(header_hash)
             if record is None:
                 # Fetch from DB
                 record = await self.service.blockchain.block_store.get_block_record(header_hash)
@@ -481,7 +482,7 @@ class FullNodeRpcApi:
         if "header_hash" not in request:
             raise ValueError("No header_hash in request")
         header_hash = bytes32.from_hexstr(request["header_hash"])
-        full_block: Optional[FullBlock] = await self.service.block_store.get_full_block(header_hash)
+        full_block: FullBlock | None = await self.service.block_store.get_full_block(header_hash)
         if full_block is None:
             raise ValueError(f"Block {header_hash.hex()} not found")
 
@@ -489,7 +490,14 @@ class FullNodeRpcApi:
         if block_generator is None:  # if block is not a transaction block.
             return {"block_spends": []}
 
-        flags = get_flags_for_height_and_constants(full_block.height, self.service.constants)
+        prev_tx_height = pre_sp_tx_block_height(
+            constants=self.service.constants,
+            blocks=self.service.blockchain,
+            prev_b_hash=full_block.prev_header_hash,
+            sp_index=full_block.reward_chain_block.signage_point_index,
+            first_in_sub_slot=len(full_block.finished_sub_slots) > 0,
+        )
+        flags = get_flags_for_height_and_constants(prev_tx_height, self.service.constants)
         spends = await asyncio.get_running_loop().run_in_executor(
             self.executor,
             get_spends_for_trusted_block,
@@ -505,7 +513,7 @@ class FullNodeRpcApi:
         if "header_hash" not in request:
             raise ValueError("No header_hash in request")
         header_hash = bytes32.from_hexstr(request["header_hash"])
-        full_block: Optional[FullBlock] = await self.service.block_store.get_full_block(header_hash)
+        full_block: FullBlock | None = await self.service.block_store.get_full_block(header_hash)
         if full_block is None:
             raise ValueError(f"Block {header_hash.hex()} not found")
 
@@ -513,7 +521,14 @@ class FullNodeRpcApi:
         if block_generator is None:  # if block is not a transaction block.
             return {"block_spends_with_conditions": []}
 
-        flags = get_flags_for_height_and_constants(full_block.height, self.service.constants)
+        prev_tx_height = pre_sp_tx_block_height(
+            constants=self.service.constants,
+            blocks=self.service.blockchain,
+            prev_b_hash=full_block.prev_header_hash,
+            sp_index=full_block.reward_chain_block.signage_point_index,
+            first_in_sub_slot=len(full_block.finished_sub_slots) > 0,
+        )
+        flags = get_flags_for_height_and_constants(prev_tx_height, self.service.constants)
         spends_with_conditions = await asyncio.get_running_loop().run_in_executor(
             self.executor,
             get_spends_for_trusted_block_with_conditions,
@@ -532,10 +547,10 @@ class FullNodeRpcApi:
         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")
-        header_hash: Optional[bytes32] = self.service.blockchain.height_to_hash(header_height)
+        header_hash: bytes32 | None = self.service.blockchain.height_to_hash(header_height)
         if header_hash is None:
             raise ValueError(f"Block hash {height} not found in chain")
-        record: Optional[BlockRecord] = self.service.blockchain.try_block_record(header_hash)
+        record: BlockRecord | None = self.service.blockchain.try_block_record(header_hash)
         if record is None:
             # Fetch from DB
             record = await self.service.blockchain.block_store.get_block_record(header_hash)
@@ -548,7 +563,7 @@ class FullNodeRpcApi:
             raise ValueError("header_hash not in request")
         header_hash_str = request["header_hash"]
         header_hash = bytes32.from_hexstr(header_hash_str)
-        record: Optional[BlockRecord] = self.service.blockchain.try_block_record(header_hash)
+        record: BlockRecord | None = self.service.blockchain.try_block_record(header_hash)
         if record is None:
             # Fetch from DB
             record = await self.service.blockchain.block_store.get_block_record(header_hash)
@@ -558,7 +573,7 @@ class FullNodeRpcApi:
         return {"block_record": record}
 
     async def get_unfinished_block_headers(self, _request: dict[str, Any]) -> EndpointResult:
-        peak: Optional[BlockRecord] = self.service.blockchain.get_peak()
+        peak: BlockRecord | None = self.service.blockchain.get_peak()
         if peak is None:
             return {"headers": []}
 
@@ -606,7 +621,7 @@ class FullNodeRpcApi:
 
         # TODO: todo_v2_plots Update this calculation to take v2 plots into
         # account
-        plot_filter_size = calculate_prefix_bits(self.service.constants, newer_block.height, PlotSize.make_v1(32))
+        plot_filter_size = calculate_prefix_bits(self.service.constants, newer_block.height, PlotParam.make_v1(32))
         delta_iters = newer_block.total_iters - older_block.total_iters
         weight_div_iters = delta_weight / delta_iters
         additional_difficulty_constant = self.service.constants.DIFFICULTY_CONSTANT_FACTOR
@@ -668,7 +683,7 @@ class FullNodeRpcApi:
             raise ValueError("Name not in request")
         name = bytes32.from_hexstr(request["name"])
 
-        coin_record: Optional[CoinRecord] = await self.service.blockchain.coin_store.get_coin_record(name)
+        coin_record: CoinRecord | None = await self.service.blockchain.coin_store.get_coin_record(name)
         if coin_record is None:
             raise ValueError(f"Coin record 0x{name.hex()} not found")
 
@@ -781,23 +796,30 @@ class FullNodeRpcApi:
 
         header_hash = self.service.blockchain.height_to_hash(height)
         assert header_hash is not None
-        block: Optional[FullBlock] = await self.service.block_store.get_full_block(header_hash)
+        block: FullBlock | None = await self.service.block_store.get_full_block(header_hash)
 
         if block is None or block.transactions_generator is None:
             raise ValueError("Invalid block or block generator")
 
-        block_generator: Optional[BlockGenerator] = await get_block_generator(
+        block_generator: BlockGenerator | None = await get_block_generator(
             self.service.blockchain.lookup_block_generators, block
         )
         assert block_generator is not None
 
         try:
+            prev_tx_height = pre_sp_tx_block_height(
+                constants=self.service.constants,
+                blocks=self.service.blockchain,
+                prev_b_hash=block.prev_header_hash,
+                sp_index=block.reward_chain_block.signage_point_index,
+                first_in_sub_slot=len(block.finished_sub_slots) > 0,
+            )
             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),
+                get_flags_for_height_and_constants(prev_tx_height, self.service.constants),
             )
             return {"coin_solution": CoinSpend(coin_record.coin, puzzle, solution)}
         except Exception as e:
@@ -808,7 +830,7 @@ class FullNodeRpcApi:
             raise ValueError("No header_hash in request")
         header_hash = bytes32.from_hexstr(request["header_hash"])
 
-        block: Optional[FullBlock] = await self.service.block_store.get_full_block(header_hash)
+        block: FullBlock | None = await self.service.block_store.get_full_block(header_hash)
         if block is None:
             raise ValueError(f"Block {header_hash.hex()} not found")
 
@@ -862,7 +884,7 @@ class FullNodeRpcApi:
 
         # Grab best transactions from Mempool for given tip target
         async with self.service.blockchain.priority_mutex.acquire(priority=BlockchainMutexPriority.low):
-            peak: Optional[BlockRecord] = self.service.blockchain.get_peak()
+            peak: BlockRecord | None = self.service.blockchain.get_peak()
 
             if peak is None:
                 return {
@@ -998,7 +1020,7 @@ class FullNodeRpcApi:
 
         if peak is None:
             peak_height = uint32(0)
-            last_peak_timestamp: Optional[uint64] = uint64(0)
+            last_peak_timestamp: uint64 | None = 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

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
-from typing import Any, Optional, cast
+from typing import Any, cast
 
-from chia_rs import BlockRecord, CoinSpend, EndOfSubSlotBundle, FullBlock, SpendBundle
+from chia_rs import BlockRecord, CoinRecord, CoinSpend, EndOfSubSlotBundle, FullBlock, SpendBundle
 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 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
@@ -46,7 +45,7 @@ class FullNodeRpcClient(RpcClient):
         )
         return [FullBlock.from_json_dict(block) for block in response["blocks"]]
 
-    async def get_block_record_by_height(self, height: int) -> Optional[BlockRecord]:
+    async def get_block_record_by_height(self, height: int) -> BlockRecord | None:
         try:
             response = await self.fetch("get_block_record_by_height", {"height": height})
         except ResponseFailureError as e:  # Block Height not found
@@ -55,7 +54,7 @@ class FullNodeRpcClient(RpcClient):
             raise e
         return BlockRecord.from_json_dict(response["block_record"])
 
-    async def get_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
+    async def get_block_record(self, header_hash: bytes32) -> BlockRecord | None:
         response = await self.fetch("get_block_record", {"header_hash": header_hash.hex()})
         if response["block_record"] is None:
             return None
@@ -88,8 +87,8 @@ class FullNodeRpcClient(RpcClient):
         self,
         names: list[bytes32],
         include_spent_coins: bool = True,
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
+        start_height: int | None = None,
+        end_height: int | None = None,
     ) -> list[CoinRecord]:
         names_hex = [name.hex() for name in names]
         d = {"names": names_hex, "include_spent_coins": include_spent_coins}
@@ -105,8 +104,8 @@ class FullNodeRpcClient(RpcClient):
         self,
         puzzle_hash: bytes32,
         include_spent_coins: bool = True,
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
+        start_height: int | None = None,
+        end_height: int | None = None,
     ) -> list[CoinRecord]:
         d = {"puzzle_hash": puzzle_hash.hex(), "include_spent_coins": include_spent_coins}
         if start_height is not None:
@@ -121,8 +120,8 @@ class FullNodeRpcClient(RpcClient):
         self,
         puzzle_hashes: list[bytes32],
         include_spent_coins: bool = True,
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
+        start_height: int | None = None,
+        end_height: int | None = None,
     ) -> list[CoinRecord]:
         puzzle_hashes_hex = [ph.hex() for ph in puzzle_hashes]
         d = {"puzzle_hashes": puzzle_hashes_hex, "include_spent_coins": include_spent_coins}
@@ -138,8 +137,8 @@ class FullNodeRpcClient(RpcClient):
         self,
         parent_ids: list[bytes32],
         include_spent_coins: bool = True,
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
+        start_height: int | None = None,
+        end_height: int | None = None,
     ) -> list[CoinRecord]:
         parent_ids_hex = [pid.hex() for pid in parent_ids]
         d = {"parent_ids": parent_ids_hex, "include_spent_coins": include_spent_coins}
@@ -159,8 +158,8 @@ class FullNodeRpcClient(RpcClient):
         self,
         hint: bytes32,
         include_spent_coins: bool = True,
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
+        start_height: int | None = None,
+        end_height: int | None = None,
     ) -> list[CoinRecord]:
         d = {"hint": hint.hex(), "include_spent_coins": include_spent_coins}
         if start_height is not None:
@@ -247,12 +246,12 @@ class FullNodeRpcClient(RpcClient):
         response = await self.fetch("get_mempool_items_by_coin_name", {"coin_name": coin_name.hex()})
         return response
 
-    async def create_block_generator(self) -> Optional[dict[str, Any]]:
+    async def create_block_generator(self) -> dict[str, Any] | None:
         response = await self.fetch("create_block_generator", {})
         return response
 
     async def get_recent_signage_point_or_eos(
-        self, sp_hash: Optional[bytes32], challenge_hash: Optional[bytes32]
+        self, sp_hash: bytes32 | None, challenge_hash: bytes32 | 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.")
@@ -275,8 +274,8 @@ class FullNodeRpcClient(RpcClient):
 
     async def get_fee_estimate(
         self,
-        target_times: Optional[list[int]],
-        cost: Optional[int],
+        target_times: list[int] | None,
+        cost: int | None,
     ) -> dict[str, Any]:
         response = await self.fetch("get_fee_estimate", {"cost": cost, "target_times": target_times})
         return response