chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/util/blockchain.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 import contextlib
 import os
 import pickle
+from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import AsyncIterator, List, Optional, Tuple
+from typing import Optional
 
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.constants import ConsensusConstants
@@ -19,12 +20,12 @@ from chia.util.default_root import DEFAULT_ROOT_PATH
 @contextlib.asynccontextmanager
 async def create_blockchain(
     constants: ConsensusConstants, db_version: int
-) -> AsyncIterator[Tuple[Blockchain, DBWrapper2]]:
+) -> AsyncIterator[tuple[Blockchain, DBWrapper2]]:
     db_uri = generate_in_memory_db_uri()
     async with DBWrapper2.managed(database=db_uri, uri=True, reader_count=1, db_version=db_version) as wrapper:
         coin_store = await CoinStore.create(wrapper)
         store = await BlockStore.create(wrapper)
-        bc1 = await Blockchain.create(coin_store, store, constants, Path("."), 2, single_threaded=True)
+        bc1 = await Blockchain.create(coin_store, store, constants, Path("."), 2, single_threaded=True, log_coins=True)
         try:
             assert bc1.get_peak() is None
             yield bc1, wrapper
@@ -43,11 +44,11 @@ def persistent_blocks(
     normalized_to_identity_icc_eos: bool = False,
     normalized_to_identity_cc_sp: bool = False,
     normalized_to_identity_cc_ip: bool = False,
-    block_list_input: Optional[List[FullBlock]] = None,
+    block_list_input: Optional[list[FullBlock]] = None,
     time_per_block: Optional[float] = None,
     dummy_block_references: bool = False,
     include_transactions: bool = False,
-) -> List[FullBlock]:
+) -> list[FullBlock]:
     # try loading from disc, if not create new blocks.db file
     # TODO hash fixtures.py and blocktool.py, add to path, delete if the files changed
     if block_list_input is None:
@@ -65,8 +66,8 @@ def persistent_blocks(
         print(f"File found at: {file_path}")
         try:
             bytes_list = file_path.read_bytes()
-            block_bytes_list: List[bytes] = pickle.loads(bytes_list)
-            blocks: List[FullBlock] = []
+            block_bytes_list: list[bytes] = pickle.loads(bytes_list)
+            blocks: list[FullBlock] = []
             for block_bytes in block_bytes_list:
                 blocks.append(FullBlock.from_bytes_unchecked(block_bytes))
             if len(blocks) == num_of_blocks + len(block_list_input):
@@ -101,7 +102,7 @@ def new_test_db(
     seed: bytes,
     empty_sub_slots: int,
     bt: BlockTools,
-    block_list_input: List[FullBlock],
+    block_list_input: list[FullBlock],
     time_per_block: Optional[float],
     *,
     normalized_to_identity_cc_eos: bool = False,  # CC_EOS,
@@ -110,9 +111,9 @@ def new_test_db(
     normalized_to_identity_cc_ip: bool = False,  # CC_IP
     dummy_block_references: bool = False,
     include_transactions: bool = False,
-) -> List[FullBlock]:
+) -> list[FullBlock]:
     print(f"create {path} with {num_of_blocks} blocks with ")
-    blocks: List[FullBlock] = bt.get_consecutive_blocks(
+    blocks: list[FullBlock] = bt.get_consecutive_blocks(
         num_of_blocks,
         block_list_input=block_list_input,
         time_per_block=time_per_block,
@@ -125,7 +126,7 @@ def new_test_db(
         dummy_block_references=dummy_block_references,
         include_transactions=include_transactions,
     )
-    block_bytes_list: List[bytes] = []
+    block_bytes_list: list[bytes] = []
     for block in blocks:
         block_bytes_list.append(bytes(block))
     bytes_fn = pickle.dumps(block_bytes_list)

chia/_tests/util/blockchain_mock.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, ClassVar, Dict, List, Optional, Set, cast
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
 from chia.consensus.block_record import BlockRecord
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -21,10 +21,10 @@ class BlockchainMock:
 
     def __init__(
         self,
-        blocks: Dict[bytes32, BlockRecord],
-        headers: Optional[Dict[bytes32, HeaderBlock]] = None,
-        height_to_hash: Optional[Dict[uint32, bytes32]] = None,
-        sub_epoch_summaries: Optional[Dict[uint32, SubEpochSummary]] = None,
+        blocks: dict[bytes32, BlockRecord],
+        headers: Optional[dict[bytes32, HeaderBlock]] = None,
+        height_to_hash: Optional[dict[uint32, bytes32]] = None,
+        sub_epoch_summaries: Optional[dict[uint32, SubEpochSummary]] = None,
     ):
         if sub_epoch_summaries is None:
             sub_epoch_summaries = {}
@@ -36,7 +36,7 @@ class BlockchainMock:
         self._headers = headers
         self._height_to_hash = height_to_hash
         self._sub_epoch_summaries = sub_epoch_summaries
-        self._sub_epoch_segments: Dict[bytes32, SubEpochSegments] = {}
+        self._sub_epoch_segments: dict[bytes32, SubEpochSegments] = {}
         self.log = logging.getLogger(__name__)
 
     def get_peak(self) -> Optional[BlockRecord]:
@@ -56,7 +56,7 @@ class BlockchainMock:
 
         return self.block_record(header_hash)
 
-    def get_ses_heights(self) -> List[uint32]:
+    def get_ses_heights(self) -> list[uint32]:
         return sorted(self._sub_epoch_summaries.keys())
 
     def get_ses(self, height: uint32) -> SubEpochSummary:
@@ -78,11 +78,11 @@ class BlockchainMock:
     async def warmup(self, fork_point: uint32) -> None:
         return
 
-    async def get_block_records_in_range(self, start: int, stop: int) -> Dict[bytes32, BlockRecord]:
+    async def get_block_records_in_range(self, start: int, stop: int) -> dict[bytes32, BlockRecord]:
         return self._block_records
 
-    async def get_block_records_at(self, heights: List[uint32]) -> List[BlockRecord]:
-        block_records: List[BlockRecord] = []
+    async def get_block_records_at(self, heights: list[uint32]) -> list[BlockRecord]:
+        block_records: list[BlockRecord] = []
         for height in heights:
             block_records.append(self.height_to_block_record(height))
         return block_records
@@ -93,7 +93,7 @@ class BlockchainMock:
     async def get_block_record_from_db(self, header_hash: bytes32) -> Optional[BlockRecord]:
         return self._block_records[header_hash]
 
-    async def prev_block_hash(self, header_hashes: List[bytes32]) -> List[bytes32]:
+    async def prev_block_hash(self, header_hashes: list[bytes32]) -> list[bytes32]:
         ret = []
         for h in header_hashes:
             ret.append(self._block_records[h].prev_hash)
@@ -107,18 +107,18 @@ class BlockchainMock:
 
     async def get_header_blocks_in_range(
         self, start: int, stop: int, tx_filter: bool = True
-    ) -> Dict[bytes32, HeaderBlock]:
+    ) -> dict[bytes32, HeaderBlock]:
         return self._headers
 
     async def persist_sub_epoch_challenge_segments(
-        self, sub_epoch_summary_hash: bytes32, segments: List[SubEpochChallengeSegment]
+        self, sub_epoch_summary_hash: bytes32, segments: list[SubEpochChallengeSegment]
     ) -> None:
         self._sub_epoch_segments[sub_epoch_summary_hash] = SubEpochSegments(segments)
 
     async def get_sub_epoch_challenge_segments(
         self,
         sub_epoch_summary_hash: bytes32,
-    ) -> Optional[List[SubEpochChallengeSegment]]:
+    ) -> Optional[list[SubEpochChallengeSegment]]:
         segments = self._sub_epoch_segments.get(sub_epoch_summary_hash)
         if segments is None:
             return None
@@ -127,6 +127,6 @@ class BlockchainMock:
     def seen_compact_proofs(self, vdf_info: VDFInfo, height: uint32) -> bool:
         return False
 
-    async def lookup_block_generators(self, header_hash: bytes32, generator_refs: Set[uint32]) -> Dict[uint32, bytes]:
+    async def lookup_block_generators(self, header_hash: bytes32, generator_refs: set[uint32]) -> dict[uint32, bytes]:
         # not implemented
         assert False  # pragma: no cover

chia/_tests/util/build_network_protocol_files.py

@@ -1,8 +1,9 @@
+# ruff: noqa: F405
 from __future__ import annotations
 
 import os
 import subprocess
-import sysconfig
+import sys
 from pathlib import Path
 from typing import Any, Callable
 
@@ -183,19 +184,19 @@ def get_protocol_bytes() -> bytes:
 
 
 def build_protocol_test() -> str:
-    result = """# this file is generated by build_network_protocol_files.py
+    result = """# ruff: noqa: F405
+# this file is generated by build_network_protocol_files.py
 
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Tuple
 
 from chia._tests.util.build_network_protocol_files import get_network_protocol_filename
 from chia._tests.util.network_protocol_data import *  # noqa: F403
 from chia._tests.util.protocol_messages_json import *  # noqa: F403
 
 
-def parse_blob(input_bytes: bytes) -> Tuple[bytes, bytes]:
+def parse_blob(input_bytes: bytes) -> tuple[bytes, bytes]:
     size_bytes = input_bytes[:4]
     input_bytes = input_bytes[4:]
     size = int.from_bytes(size_bytes, "big")
@@ -233,17 +234,18 @@ def test_protocol_bytes() -> None:
 
 
 def get_protocol_json() -> str:
-    result = """# this file is generated by build_network_protocol_files.py
+    result = """# ruff: noqa: E501
+# this file is generated by build_network_protocol_files.py
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any
 """
     counter = 0
 
     def visitor(obj: Any, name: str) -> None:
         nonlocal result
         nonlocal counter
-        result += f"\n{name}_json: Dict[str, Any] = {obj.to_json_dict()}\n"
+        result += f"\n{name}_json: dict[str, Any] = {obj.to_json_dict()}\n"
         counter += 1
 
     visit_all_messages(visitor)
@@ -252,7 +254,8 @@ from typing import Any, Dict
 
 
 def build_json_test() -> str:
-    result = """# this file is generated by build_network_protocol_files.py
+    result = """# ruff: noqa: F405
+# this file is generated by build_network_protocol_files.py
 
 from __future__ import annotations
 
@@ -285,14 +288,11 @@ def main() -> None:
         "test_network_protocol_json.py": build_json_test,
     }
 
-    scripts_path = Path(sysconfig.get_path("scripts"))
-
     for name, function in name_to_function.items():
         path = tests_dir.joinpath(name)
         path.write_text(function())
-        # black seems to have trouble when run as a module so not using `python -m black`
         subprocess.run(
-            [scripts_path.joinpath("black"), os.fspath(path.relative_to(tests_dir))],
+            [sys.executable, "-m", "ruff", "format", os.fspath(path.relative_to(tests_dir))],
             check=True,
             cwd=tests_dir,
         )

chia/_tests/util/db_connection.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import tempfile
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import AsyncIterator, Optional, Type
+from typing import Optional
 
 import aiosqlite
 
@@ -14,7 +15,7 @@ from chia.util.db_wrapper import DBWrapper2, generate_in_memory_db_uri
 async def DBConnection(
     db_version: int,
     foreign_keys: Optional[bool] = None,
-    row_factory: Optional[Type[aiosqlite.Row]] = None,
+    row_factory: Optional[type[aiosqlite.Row]] = None,
 ) -> AsyncIterator[DBWrapper2]:
     db_uri = generate_in_memory_db_uri()
     async with DBWrapper2.managed(

chia/_tests/util/full_sync.py

@@ -5,15 +5,17 @@ import logging
 import shutil
 import tempfile
 import time
+from collections.abc import Iterator
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Callable, Iterator, List, Optional, cast
+from typing import Callable, Optional, cast
 
 import aiosqlite
 import zstd
 
 from chia._tests.util.constants import test_constants as TEST_CONSTANTS
 from chia.cmds.init_funcs import chia_init
+from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
@@ -25,6 +27,7 @@ from chia.simulator.block_tools import make_unfinished_block
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.full_block import FullBlock
 from chia.types.peer_info import PeerInfo
+from chia.types.validation_state import ValidationState
 from chia.util.config import load_config
 from chia.util.ints import uint16
 
@@ -57,13 +60,13 @@ def enable_profiler(profile: bool, counter: int) -> Iterator[None]:
 
 class FakeServer:
     async def send_to_all(
-        self, messages: List[Message], node_type: NodeType, exclude: Optional[bytes32] = None
+        self, messages: list[Message], node_type: NodeType, exclude: Optional[bytes32] = None
     ) -> None:
         pass
 
     async def send_to_all_if(
         self,
-        messages: List[Message],
+        messages: list[Message],
         node_type: NodeType,
         predicate: Callable[[WSChiaConnection], bool],
         exclude: Optional[bytes32] = None,
@@ -78,7 +81,7 @@ class FakeServer:
 
     def get_connections(
         self, node_type: Optional[NodeType] = None, *, outbound: Optional[bool] = False
-    ) -> List[WSChiaConnection]:
+    ) -> list[WSChiaConnection]:
         return []
 
     def is_duplicate_or_self_connection(self, target_node: PeerInfo) -> bool:
@@ -206,8 +209,13 @@ async def run_sync_test(
                             ssi, diff = get_next_sub_slot_iters_and_difficulty(
                                 full_node.constants, True, block_record, full_node.blockchain
                             )
-                            success, summary, _, _, _, _ = await full_node.add_block_batch(
-                                block_batch, peer_info, None, current_ssi=ssi, current_difficulty=diff
+                            fork_height = block_batch[0].height - 1
+                            header_hash = block_batch[0].prev_header_hash
+                            success, summary = await full_node.add_block_batch(
+                                block_batch,
+                                peer_info,
+                                ForkInfo(fork_height, fork_height, header_hash),
+                                ValidationState(ssi, diff, None),
                             )
                             end_height = block_batch[-1].height
                             full_node.blockchain.clean_block_record(end_height - full_node.constants.BLOCKS_CACHE_SIZE)

chia/_tests/util/gen_ssl_certs.py

@@ -43,9 +43,6 @@ def gen_ssl(suffix: str = "") -> None:
     private_ca_key: Optional[bytes] = None
     capture_cert_and_key = True
 
-    print("from typing import Dict, Tuple")
-    print()
-
     make_ca_cert(Path("SSL_TEST_PRIVATE_CA_CRT"), Path("SSL_TEST_PRIVATE_CA_KEY"))
 
     capture_cert_and_key = False
@@ -86,17 +83,19 @@ def gen_ssl(suffix: str = "") -> None:
             ca_crt = chia_ca_crt if cert_type == "public" else private_ca_crt
             ca_key = chia_ca_key if cert_type == "public" else private_ca_key
 
+            assert ca_crt is not None
+            assert ca_key is not None
             generate_ca_signed_cert(ca_crt, ca_key, Path(crt), Path(key))
 
     patch.undo()
 
     append_str = "" if suffix == "" else f"_{suffix}"
     print(
-        f"SSL_TEST_PRIVATE_CA_CERT_AND_KEY{append_str}: Tuple[bytes, bytes] = "
+        f"SSL_TEST_PRIVATE_CA_CERT_AND_KEY{append_str}: tuple[bytes, bytes] = "
         "(SSL_TEST_PRIVATE_CA_CRT, SSL_TEST_PRIVATE_CA_KEY)"
     )
     print()
-    print(f"SSL_TEST_NODE_CERTS_AND_KEYS{append_str}: Dict[str, Dict[str, Dict[str, bytes]]] = {{")
+    print(f"SSL_TEST_NODE_CERTS_AND_KEYS{append_str}: dict[str, dict[str, dict[str, bytes]]] = {{")
     for node_name, cert_type_dict in node_certs_and_keys.items():
         print(f'    "{node_name}": {{')
         for cert_type, cert_dict in cert_type_dict.items():

chia/_tests/util/generator_tools_testing.py

@@ -1,10 +1,8 @@
 from __future__ import annotations
 
-from typing import List, Tuple
-
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia.consensus.constants import ConsensusConstants
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.full_block import FullBlock
@@ -19,10 +17,10 @@ def run_and_get_removals_and_additions(
     *,
     height: uint32,
     constants: ConsensusConstants = DEFAULT_CONSTANTS,
-    mempool_mode=False,
-) -> Tuple[List[bytes32], List[Coin]]:
-    removals: List[bytes32] = []
-    additions: List[Coin] = []
+    mempool_mode: bool = False,
+) -> tuple[list[bytes32], list[Coin]]:
+    removals: list[bytes32] = []
+    additions: list[Coin] = []
 
     assert len(block.transactions_generator_ref_list) == 0
     if not block.is_transaction_block():

chia/_tests/util/get_name_puzzle_conditions.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import logging
+
+from chia_rs import (
+    DONT_VALIDATE_SIGNATURE,
+    MEMPOOL_MODE,
+    G2Element,
+    get_flags_for_height_and_constants,
+    run_block_generator,
+    run_block_generator2,
+)
+
+from chia.consensus.constants import ConsensusConstants
+from chia.consensus.cost_calculator import NPCResult
+from chia.types.generator_types import BlockGenerator
+from chia.util.errors import Err
+from chia.util.ints import uint16, uint32
+
+log = logging.getLogger(__name__)
+
+
+def get_name_puzzle_conditions(
+    generator: BlockGenerator,
+    max_cost: int,
+    *,
+    mempool_mode: bool,
+    height: uint32,
+    constants: ConsensusConstants,
+) -> NPCResult:
+    flags = get_flags_for_height_and_constants(height, constants) | DONT_VALIDATE_SIGNATURE
+
+    if mempool_mode:
+        flags |= MEMPOOL_MODE
+
+    if height >= constants.HARD_FORK_HEIGHT:
+        run_block = run_block_generator2
+    else:
+        run_block = run_block_generator
+
+    try:
+        block_args = generator.generator_refs
+        err, result = run_block(bytes(generator.program), block_args, max_cost, flags, G2Element(), None, constants)
+        assert (err is None) != (result is None)
+        if err is not None:
+            return NPCResult(uint16(err), None)
+        else:
+            assert result is not None
+            return NPCResult(None, result)
+    except BaseException:
+        log.exception("get_name_puzzle_condition failed")
+        return NPCResult(uint16(Err.GENERATOR_RUNTIME_ERROR.value), None)

chia/_tests/util/key_tool.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Dict, List
 
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
 
@@ -13,9 +12,9 @@ from chia.util.condition_tools import conditions_dict_for_solution, pkm_pairs_fo
 
 @dataclass
 class KeyTool:
-    dict: Dict[G1Element, int] = field(default_factory=dict)
+    dict: dict[G1Element, int] = field(default_factory=dict)
 
-    def add_secret_exponents(self, secret_exponents: List[int]) -> None:
+    def add_secret_exponents(self, secret_exponents: list[int]) -> None:
         for _ in secret_exponents:
             self.dict[int_to_public_key(_)] = _ % GROUP_ORDER