chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/simulator/block_tools.py

@@ -10,13 +10,14 @@ import ssl
 import sys
 import tempfile
 import time
+from collections.abc import Sequence
 from dataclasses import dataclass, replace
 from pathlib import Path
 from random import Random
-from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
+from typing import Any, Callable, Optional
 
 import anyio
-from chia_rs import ALLOW_BACKREFS, MEMPOOL_MODE, AugSchemeMPL, G1Element, G2Element, PrivateKey, solution_generator
+from chia_rs import MEMPOOL_MODE, AugSchemeMPL, G1Element, G2Element, PrivateKey, solution_generator
 
 from chia.consensus.block_creation import create_unfinished_block, unfinished_block_to_full_block
 from chia.consensus.block_record import BlockRecord
@@ -147,8 +148,8 @@ test_constants = DEFAULT_CONSTANTS.replace(
 )
 
 
-def compute_additions_unchecked(sb: SpendBundle) -> List[Coin]:
-    ret: List[Coin] = []
+def compute_additions_unchecked(sb: SpendBundle) -> list[Coin]:
+    ret: list[Coin] = []
     for cs in sb.coin_spends:
         parent_id = cs.coin.name()
         _, r = cs.puzzle_reveal.run_with_cost(INFINITE_COST, cs.solution)
@@ -163,14 +164,14 @@ def compute_additions_unchecked(sb: SpendBundle) -> List[Coin]:
     return ret
 
 
-def make_spend_bundle(coins: List[Coin], wallet: WalletTool, rng: Random) -> Tuple[SpendBundle, List[Coin]]:
+def make_spend_bundle(coins: list[Coin], wallet: WalletTool, rng: Random) -> tuple[SpendBundle, list[Coin]]:
     """
     makes a new spend bundle (block generator) spending some of the coins in the
     list of coins. The list will be updated to have spent coins removed and new
     coins appended.
     """
-    new_coins: List[Coin] = []
-    spend_bundles: List[SpendBundle] = []
+    new_coins: list[Coin] = []
+    spend_bundles: list[SpendBundle] = []
     to_spend = rng.sample(coins, min(5, len(coins)))
     receiver = wallet.get_new_puzzlehash()
     for c in to_spend:
@@ -190,21 +191,21 @@ class BlockTools:
     """
 
     _block_cache_header: bytes32
-    _block_cache_height_to_hash: Dict[uint32, bytes32]
+    _block_cache_height_to_hash: dict[uint32, bytes32]
     _block_cache_difficulty: uint64
-    _block_cache: Dict[bytes32, BlockRecord]
+    _block_cache: dict[bytes32, BlockRecord]
 
     def __init__(
         self,
         constants: ConsensusConstants = test_constants,
         root_path: Optional[Path] = None,
         keychain: Optional[Keychain] = None,
-        config_overrides: Optional[Dict[str, Any]] = None,
+        config_overrides: Optional[dict[str, Any]] = None,
         automated_testing: bool = True,
         plot_dir: str = "test-plots",
         log: logging.Logger = logging.getLogger(__name__),
     ) -> None:
-        self._block_cache_header = bytes32([0] * 32)
+        self._block_cache_header = bytes32.zeros
 
         self._tempdir = None
         if root_path is None:
@@ -214,7 +215,7 @@ class BlockTools:
         self.root_path = root_path
         self.log = log
         self.local_keychain = keychain
-        self.local_sk_cache: Dict[bytes32, Tuple[PrivateKey, Any]] = {}
+        self.local_sk_cache: dict[bytes32, tuple[PrivateKey, Any]] = {}
         self.automated_testing = automated_testing
         self.plot_dir_name = plot_dir
 
@@ -270,7 +271,7 @@ class BlockTools:
         self.temp_dir: Path = get_plot_tmp_dir(self.plot_dir_name, self.automated_testing)
         self.plot_dir.mkdir(parents=True, exist_ok=True)
         self.temp_dir.mkdir(parents=True, exist_ok=True)
-        self.expected_plots: Dict[bytes32, Path] = {}
+        self.expected_plots: dict[bytes32, Path] = {}
         self.created_plots: int = 0
         self.total_result = PlotRefreshResult()
 
@@ -342,12 +343,12 @@ class BlockTools:
                 self.farmer_ph = reward_ph
                 self.pool_ph = reward_ph
             if self.automated_testing:
-                self.all_sks: List[PrivateKey] = [sk for sk, _ in await keychain_proxy.get_all_private_keys()]
+                self.all_sks: list[PrivateKey] = [sk for sk, _ in await keychain_proxy.get_all_private_keys()]
             else:
                 self.all_sks = [self.farmer_master_sk]  # we only want to include plots under the same fingerprint
-            self.pool_pubkeys: List[G1Element] = [master_sk_to_pool_sk(sk).get_g1() for sk in self.all_sks]
+            self.pool_pubkeys: list[G1Element] = [master_sk_to_pool_sk(sk).get_g1() for sk in self.all_sks]
 
-            self.farmer_pubkeys: List[G1Element] = [master_sk_to_farmer_sk(sk).get_g1() for sk in self.all_sks]
+            self.farmer_pubkeys: list[G1Element] = [master_sk_to_farmer_sk(sk).get_g1() for sk in self.all_sks]
             if len(self.pool_pubkeys) == 0 or len(self.farmer_pubkeys) == 0:
                 raise RuntimeError("Keys not generated. Run `chia keys generate`")
 
@@ -356,7 +357,7 @@ class BlockTools:
             if keychain_proxy is not None:
                 await keychain_proxy.close()  # close the keychain proxy
 
-    def change_config(self, new_config: Dict[str, Any]) -> None:
+    def change_config(self, new_config: dict[str, Any]) -> None:
         self._config = new_config
         overrides = self._config["network_overrides"]["constants"][self._config["selected_network"]]
         updated_constants = replace_str_to_bytes(self.constants, **overrides)
@@ -462,11 +463,11 @@ class BlockTools:
 
             if len(created):
                 assert len(existed) == 0
-                plot_id_new, path_new = list(created.items())[0]
+                plot_id_new, path_new = next(iter(created.items()))
 
             if len(existed):
                 assert len(created) == 0
-                plot_id_new, path_new = list(existed.items())[0]
+                plot_id_new, path_new = next(iter(existed.items()))
                 new_plot = False
             assert plot_id_new is not None
             assert path_new is not None
@@ -505,7 +506,7 @@ class BlockTools:
         await self.refresh_plots()
 
     @property
-    def config(self) -> Dict[str, Any]:
+    def config(self) -> dict[str, Any]:
         return copy.deepcopy(self._config)
 
     def get_daemon_ssl_context(self) -> ssl.SSLContext:
@@ -567,7 +568,7 @@ class BlockTools:
     def get_consecutive_blocks(
         self,
         num_blocks: int,
-        block_list_input: Optional[List[FullBlock]] = None,
+        block_list_input: Optional[list[FullBlock]] = None,
         *,
         farmer_reward_puzzle_hash: Optional[bytes32] = None,
         pool_reward_puzzle_hash: Optional[bytes32] = None,
@@ -583,21 +584,21 @@ class BlockTools:
         normalized_to_identity_cc_sp: bool = False,
         normalized_to_identity_cc_ip: bool = False,
         current_time: bool = False,
-        block_refs: List[uint32] = [],
+        block_refs: list[uint32] = [],
         genesis_timestamp: Optional[uint64] = None,
         force_plot_id: Optional[bytes32] = None,
         dummy_block_references: bool = False,
         include_transactions: bool = False,
         skip_overflow: bool = False,
         min_signage_point: int = -1,
-    ) -> List[FullBlock]:
+    ) -> list[FullBlock]:
         assert num_blocks > 0
         if block_list_input is not None:
             block_list = block_list_input.copy()
         else:
             block_list = []
 
-        tx_block_heights: List[uint32] = []
+        tx_block_heights: list[uint32] = []
         if dummy_block_references:
             # block references can only point to transaction blocks, so we need
             # to record which ones are
@@ -610,8 +611,8 @@ class BlockTools:
         if time_per_block is None:
             time_per_block = float(constants.SUB_SLOT_TIME_TARGET) / float(constants.SLOT_BLOCKS_TARGET)
 
-        available_coins: List[Coin] = []
-        pending_rewards: List[Coin] = []
+        available_coins: list[Coin] = []
+        pending_rewards: list[Coin] = []
         wallet: Optional[WalletTool] = None
         rng: Optional[Random] = None
         if include_transactions:
@@ -658,7 +659,7 @@ class BlockTools:
         if num_blocks == 0:
             return block_list
 
-        blocks: Dict[bytes32, BlockRecord]
+        blocks: dict[bytes32, BlockRecord]
         if block_list[-1].header_hash == self._block_cache_header:
             height_to_hash = self._block_cache_height_to_hash
             difficulty = self._block_cache_difficulty
@@ -681,8 +682,8 @@ class BlockTools:
             curr = blocks[curr.prev_hash]
             blocks_added_this_sub_slot += 1
 
-        finished_sub_slots_at_sp: List[EndOfSubSlotBundle] = []  # Sub-slots since last block, up to signage point
-        finished_sub_slots_at_ip: List[EndOfSubSlotBundle] = []  # Sub-slots since last block, up to infusion point
+        finished_sub_slots_at_sp: list[EndOfSubSlotBundle] = []  # Sub-slots since last block, up to signage point
+        finished_sub_slots_at_ip: list[EndOfSubSlotBundle] = []  # Sub-slots since last block, up to infusion point
         sub_slot_iters: uint64 = latest_block.sub_slot_iters  # The number of iterations in one sub-slot
         same_slot_as_last = True  # Only applies to first slot, to prevent old blocks from being added
         sub_slot_start_total_iters: uint128 = latest_block.ip_sub_slot_total_iters(constants)
@@ -741,7 +742,7 @@ class BlockTools:
                         assert signage_point.cc_vdf is not None
                         cc_sp_output_hash = signage_point.cc_vdf.output.get_hash()
 
-                    qualified_proofs: List[Tuple[uint64, ProofOfSpace]] = self.get_pospaces_for_challenge(
+                    qualified_proofs: list[tuple[uint64, ProofOfSpace]] = self.get_pospaces_for_challenge(
                         constants,
                         slot_cc_challenge,
                         cc_sp_output_hash,
@@ -961,7 +962,7 @@ class BlockTools:
                 new_sub_slot_iters: Optional[uint64] = sub_epoch_summary.new_sub_slot_iters
                 new_difficulty: Optional[uint64] = sub_epoch_summary.new_difficulty
 
-                self.log.info(f"Sub epoch summary: {sub_epoch_summary} for block {latest_block.height+1}")
+                self.log.info(f"Sub epoch summary: {sub_epoch_summary} for block {latest_block.height + 1}")
             else:  # the previous block is not the last block of the sub-epoch or epoch
                 pending_ses = False
                 ses_hash = None
@@ -1044,7 +1045,7 @@ class BlockTools:
             sub_slots_finished += 1
             self.log.info(
                 f"Sub slot finished. blocks included: {blocks_added_this_sub_slot} blocks_per_slot: "
-                f"{(len(block_list) - initial_block_list_len)/sub_slots_finished}"
+                f"{(len(block_list) - initial_block_list_len) / sub_slots_finished}"
                 f"Sub Epoch Summary Included: {sub_epoch_summary is not None} "
             )
             blocks_added_this_sub_slot = 0  # Sub slot ended, overflows are in next sub slot
@@ -1236,7 +1237,7 @@ class BlockTools:
         if timestamp is None:
             timestamp = uint64(int(time.time()))
 
-        finished_sub_slots: List[EndOfSubSlotBundle] = []
+        finished_sub_slots: list[EndOfSubSlotBundle] = []
         unfinished_block: Optional[UnfinishedBlock] = None
         ip_iters: uint64 = uint64(0)
         sub_slot_total_iters: uint128 = uint128(0)
@@ -1262,7 +1263,7 @@ class BlockTools:
                     cc_sp_output_hash = signage_point.cc_vdf.output.get_hash()
                     # If did not reach the target slots to skip, don't make any proofs for this sub-slot
                 # we're creating the genesis block, its height is always 0
-                qualified_proofs: List[Tuple[uint64, ProofOfSpace]] = self.get_pospaces_for_challenge(
+                qualified_proofs: list[tuple[uint64, ProofOfSpace]] = self.get_pospaces_for_challenge(
                     constants,
                     cc_challenge,
                     cc_sp_output_hash,
@@ -1420,8 +1421,8 @@ class BlockTools:
         sub_slot_iters: uint64,
         height: uint32,
         force_plot_id: Optional[bytes32] = None,
-    ) -> List[Tuple[uint64, ProofOfSpace]]:
-        found_proofs: List[Tuple[uint64, ProofOfSpace]] = []
+    ) -> list[tuple[uint64, ProofOfSpace]]:
+        found_proofs: list[tuple[uint64, ProofOfSpace]] = []
         rng = random.Random()
         rng.seed(seed)
         for plot_info in self.plot_manager.plots.values():
@@ -1481,7 +1482,7 @@ def get_signage_point(
     latest_block: Optional[BlockRecord],
     sub_slot_start_total_iters: uint128,
     signage_point_index: uint8,
-    finished_sub_slots: List[EndOfSubSlotBundle],
+    finished_sub_slots: list[EndOfSubSlotBundle],
     sub_slot_iters: uint64,
     normalized_to_identity_cc_sp: bool = False,
 ) -> SignagePoint:
@@ -1536,9 +1537,9 @@ def get_signage_point(
 
 def finish_block(
     constants: ConsensusConstants,
-    blocks: Dict[bytes32, BlockRecord],
-    height_to_hash: Dict[uint32, bytes32],
-    finished_sub_slots: List[EndOfSubSlotBundle],
+    blocks: dict[bytes32, BlockRecord],
+    height_to_hash: dict[uint32, bytes32],
+    finished_sub_slots: list[EndOfSubSlotBundle],
     sub_slot_start_total_iters: uint128,
     signage_point_index: uint8,
     unfinished_block: UnfinishedBlock,
@@ -1550,7 +1551,7 @@ def finish_block(
     sub_slot_iters: uint64,
     difficulty: uint64,
     normalized_to_identity_cc_ip: bool = False,
-) -> Tuple[FullBlock, BlockRecord]:
+) -> tuple[FullBlock, BlockRecord]:
     is_overflow = is_overflow_block(constants, signage_point_index)
     cc_vdf_challenge = slot_cc_challenge
     if len(finished_sub_slots) == 0:
@@ -1627,10 +1628,10 @@ def finish_block(
 
 def get_challenges(
     constants: ConsensusConstants,
-    blocks: Dict[bytes32, BlockRecord],
-    finished_sub_slots: List[EndOfSubSlotBundle],
+    blocks: dict[bytes32, BlockRecord],
+    finished_sub_slots: list[EndOfSubSlotBundle],
     prev_header_hash: Optional[bytes32],
-) -> Tuple[bytes32, bytes32]:
+) -> tuple[bytes32, bytes32]:
     if len(finished_sub_slots) == 0:
         if prev_header_hash is None:
             return constants.GENESIS_CHALLENGE, constants.GENESIS_CHALLENGE
@@ -1670,12 +1671,12 @@ def get_plot_tmp_dir(plot_dir_name: str = "test-plots", automated_testing: bool
 
 
 def load_block_list(
-    block_list: List[FullBlock], constants: ConsensusConstants
-) -> Tuple[Dict[uint32, bytes32], uint64, Dict[bytes32, BlockRecord]]:
+    block_list: list[FullBlock], constants: ConsensusConstants
+) -> tuple[dict[uint32, bytes32], uint64, dict[bytes32, BlockRecord]]:
     difficulty = uint64(constants.DIFFICULTY_STARTING)
     sub_slot_iters = uint64(constants.SUB_SLOT_ITERS_STARTING)
-    height_to_hash: Dict[uint32, bytes32] = {}
-    blocks: Dict[bytes32, BlockRecord] = {}
+    height_to_hash: dict[uint32, bytes32] = {}
+    blocks: dict[bytes32, BlockRecord] = {}
     for full_block in block_list:
         if full_block.height != 0:
             if len(full_block.finished_sub_slots) > 0:
@@ -1716,12 +1717,12 @@ def load_block_list(
 def get_icc(
     constants: ConsensusConstants,
     vdf_end_total_iters: uint128,
-    finished_sub_slots: List[EndOfSubSlotBundle],
+    finished_sub_slots: list[EndOfSubSlotBundle],
     latest_block: BlockRecord,
-    blocks: Dict[bytes32, BlockRecord],
+    blocks: dict[bytes32, BlockRecord],
     sub_slot_start_total_iters: uint128,
     deficit: uint8,
-) -> Tuple[Optional[VDFInfo], Optional[VDFProof]]:
+) -> tuple[Optional[VDFInfo], Optional[VDFProof]]:
     if len(finished_sub_slots) == 0:
         prev_deficit = latest_block.deficit
     else:
@@ -1772,7 +1773,7 @@ def get_icc(
 
 def get_full_block_and_block_record(
     constants: ConsensusConstants,
-    blocks: Dict[bytes32, BlockRecord],
+    blocks: dict[bytes32, BlockRecord],
     sub_slot_start_total_iters: uint128,
     signage_point_index: uint8,
     proof_of_space: ProofOfSpace,
@@ -1785,25 +1786,25 @@ def get_full_block_and_block_record(
     time_per_block: float,
     block_generator: Optional[BlockGenerator],
     aggregate_signature: G2Element,
-    additions: Optional[List[Coin]],
-    removals: Optional[List[Coin]],
-    height_to_hash: Dict[uint32, bytes32],
+    additions: Optional[list[Coin]],
+    removals: Optional[list[Coin]],
+    height_to_hash: dict[uint32, bytes32],
     difficulty: uint64,
     required_iters: uint64,
     sub_slot_iters: uint64,
     get_plot_signature: Callable[[bytes32, G1Element], G2Element],
     get_pool_signature: Callable[[PoolTarget, Optional[G1Element]], Optional[G2Element]],
-    finished_sub_slots: List[EndOfSubSlotBundle],
+    finished_sub_slots: list[EndOfSubSlotBundle],
     signage_point: SignagePoint,
     prev_block: BlockRecord,
     seed: bytes = b"",
     *,
-    block_refs: List[uint32] = [],
+    block_refs: list[uint32] = [],
     overflow_cc_challenge: Optional[bytes32] = None,
     overflow_rc_challenge: Optional[bytes32] = None,
     normalized_to_identity_cc_ip: bool = False,
     current_time: bool = False,
-) -> Tuple[FullBlock, BlockRecord, float]:
+) -> tuple[FullBlock, BlockRecord, float]:
     # we're simulating time between blocks here. The more VDF iterations the
     # blocks advances, the longer it should have taken (and vice versa). This
     # formula is meant to converge at 1024 iters per the specified
@@ -1870,7 +1871,7 @@ def get_full_block_and_block_record(
 
 # these are the costs of unknown conditions, as defined chia_rs here:
 # https://github.com/Chia-Network/chia_rs/pull/181
-def compute_cost_table() -> List[int]:
+def compute_cost_table() -> list[int]:
     A = 17
     B = 16
     s = []
@@ -1907,7 +1908,7 @@ def conditions_cost(conds: Program) -> uint64:
         elif condition == ConditionOpcode.SOFTFORK.value:
             arg = cond.rest().first().as_int()
             condition_cost += arg * 10000
-        elif condition in [
+        elif condition in {
             ConditionOpcode.AGG_SIG_UNSAFE,
             ConditionOpcode.AGG_SIG_ME,
             ConditionOpcode.AGG_SIG_PARENT,
@@ -1916,7 +1917,7 @@ def conditions_cost(conds: Program) -> uint64:
             ConditionOpcode.AGG_SIG_PUZZLE_AMOUNT,
             ConditionOpcode.AGG_SIG_PARENT_AMOUNT,
             ConditionOpcode.AGG_SIG_PARENT_PUZZLE,
-        ]:
+        }:
             condition_cost += ConditionCost.AGG_SIG.value
     return uint64(condition_cost)
 
@@ -1946,7 +1947,7 @@ def compute_cost_test(generator: BlockGenerator, constants: ConsensusConstants,
 
     if height >= constants.HARD_FORK_HEIGHT:
         blocks = generator.generator_refs
-        cost, result = generator.program._run(INFINITE_COST, MEMPOOL_MODE | ALLOW_BACKREFS, [DESERIALIZE_MOD, blocks])
+        cost, result = generator.program._run(INFINITE_COST, MEMPOOL_MODE, [DESERIALIZE_MOD, blocks])
         clvm_cost += cost
 
         for spend in result.first().as_iter():
@@ -1997,7 +1998,7 @@ async def create_block_tools_async(
     constants: ConsensusConstants = test_constants,
     root_path: Optional[Path] = None,
     keychain: Optional[Keychain] = None,
-    config_overrides: Optional[Dict[str, Any]] = None,
+    config_overrides: Optional[dict[str, Any]] = None,
     num_og_plots: int = 15,
     num_pool_plots: int = 5,
     num_non_keychain_plots: int = 3,
@@ -2020,7 +2021,7 @@ def create_block_tools(
     constants: ConsensusConstants = test_constants,
     root_path: Optional[Path] = None,
     keychain: Optional[Keychain] = None,
-    config_overrides: Optional[Dict[str, Any]] = None,
+    config_overrides: Optional[dict[str, Any]] = None,
 ) -> BlockTools:
     global create_block_tools_count
     create_block_tools_count += 1