chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5rc1__py3-none-any.whl

chia/_tests/core/util/test_streamable.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 import io
 import re
 from dataclasses import dataclass, field, fields
-from typing import Any, Callable, Optional, get_type_hints
+from typing import Any, Callable, ClassVar, Optional, get_type_hints
 
 import pytest
-from chia_rs import G1Element, SubEpochChallengeSegment
+from chia_rs import FullBlock, G1Element, SubEpochChallengeSegment
 from chia_rs.sized_bytes import bytes4, bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 from clvm_tools import binutils
@@ -16,7 +16,6 @@ from chia.protocols.wallet_protocol import RespondRemovals
 from chia.simulator.block_tools import BlockTools, test_constants
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.full_block import FullBlock
 from chia.util.streamable import (
     ConversionError,
     DefinitionError,
@@ -27,6 +26,7 @@ from chia.util.streamable import (
     UnsupportedType,
     function_to_parse_one_item,
     function_to_stream_one_item,
+    is_type_Dict,
     is_type_List,
     is_type_SpecificOptional,
     is_type_Tuple,
@@ -62,15 +62,6 @@ def test_float_not_supported() -> None:
             a: float
 
 
-def test_dict_not_suppported() -> None:
-    with pytest.raises(UnsupportedType):
-
-        @streamable
-        @dataclass(frozen=True)
-        class TestClassDict(Streamable):
-            a: dict[str, str]
-
-
 @dataclass(frozen=True)
 class DataclassOnly:
     a: uint8
@@ -164,6 +155,28 @@ def test_convert_list_failures(input_dict: dict[str, Any], error: Any) -> None:
         streamable_from_dict(ConvertListFailures, input_dict)
 
 
+@streamable
+@dataclass(frozen=True)
+class ConvertDictFailures(Streamable):
+    a: dict[str, str]
+    b: dict[str, dict[str, str]]
+
+
+@pytest.mark.parametrize(
+    "input_dict, error",
+    [
+        pytest.param({"a": [1, 1], "b": {"foo": [2, 2]}}, InvalidTypeError, id="a: invalid type list"),
+        pytest.param({"a": 1, "b": {"foo": "bar"}}, InvalidTypeError, id="a: invalid type int"),
+        pytest.param({"a": "11", "b": {"foo": "bar"}}, InvalidTypeError, id="a: invalid type str"),
+        pytest.param({"a": {"foo": "bar"}, "b": {1: {"foo": "bar"}}}, InvalidTypeError, id="b: invalid type int"),
+        pytest.param({"a": {"foo": "bar"}, "b": {"foo": {"foo": 1}}}, InvalidTypeError, id="b: invalid type int"),
+    ],
+)
+def test_convert_dict_failures(input_dict: dict[str, Any], error: Any) -> None:
+    with pytest.raises(error):
+        streamable_from_dict(ConvertListFailures, input_dict)
+
+
 @streamable
 @dataclass(frozen=True)
 class ConvertByteTypeFailures(Streamable):
@@ -320,16 +333,21 @@ class TestFromJsonDictDefaultValues(Streamable):
     a: uint64 = uint64(1)
     b: str = "default"
     c: list[uint64] = field(default_factory=list)
+    d: dict[str, str] = field(default_factory=dict)
 
 
 @pytest.mark.parametrize(
     "input_dict, output_dict",
     [
-        [{}, {"a": 1, "b": "default", "c": []}],
-        [{"a": 2}, {"a": 2, "b": "default", "c": []}],
-        [{"b": "not_default"}, {"a": 1, "b": "not_default", "c": []}],
-        [{"c": [1, 2]}, {"a": 1, "b": "default", "c": [1, 2]}],
-        [{"a": 2, "b": "not_default", "c": [1, 2]}, {"a": 2, "b": "not_default", "c": [1, 2]}],
+        [{}, {"a": 1, "b": "default", "c": [], "d": {}}],
+        [{"a": 2}, {"a": 2, "b": "default", "c": [], "d": {}}],
+        [{"b": "not_default"}, {"a": 1, "b": "not_default", "c": [], "d": {}}],
+        [{"c": [1, 2]}, {"a": 1, "b": "default", "c": [1, 2], "d": {}}],
+        [{"d": {"foo": "bar"}}, {"a": 1, "b": "default", "c": [], "d": {"foo": "bar"}}],
+        [
+            {"a": 2, "b": "not_default", "c": [1, 2], "d": {"foo": "bar"}},
+            {"a": 2, "b": "not_default", "c": [1, 2], "d": {"foo": "bar"}},
+        ],
     ],
 )
 def test_from_json_dict_default_values(input_dict: dict[str, object], output_dict: dict[str, object]) -> None:
@@ -372,7 +390,7 @@ class PostInitTestClassBasic(Streamable):
 @dataclass(frozen=True)
 class PostInitTestClassBad(Streamable):
     a: uint8
-    b = 0
+    b: ClassVar[uint8] = uint8(0)
 
 
 @streamable
@@ -398,6 +416,13 @@ class PostInitTestClassTuple(Streamable):
     b: tuple[tuple[uint8, str], bytes32]
 
 
+@streamable
+@dataclass(frozen=True)
+class PostInitTestClassDict(Streamable):
+    a: dict[uint8, str]
+    b: dict[bytes32, dict[uint8, str]]
+
+
 @pytest.mark.parametrize(
     "test_class, args",
     [
@@ -406,6 +431,7 @@ class PostInitTestClassTuple(Streamable):
         (PostInitTestClassBad, (25,)),
         (PostInitTestClassList, ([1, 2, 3], [[G1Element(), bytes(G1Element())], [bytes(G1Element())]])),
         (PostInitTestClassTuple, ((1, "test"), ((200, "test_2"), b"\xba" * 32))),
+        (PostInitTestClassDict, ({1: "bar"}, {bytes32.zeros: {1: "bar"}})),
         (PostInitTestClassOptional, (12, None, 13, None)),
     ],
 )
@@ -421,6 +447,12 @@ def test_post_init_valid(test_class: type[Any], args: tuple[Any, ...]) -> None:
             list_type = get_args(type_in)[0]
             assert type(item) is list
             return all(validate_item_type(list_type, list_item) for list_item in item)
+        if is_type_Dict(type_in):
+            [key_type, value_type] = get_args(type_in)
+            assert type(item) is dict
+            return validate_item_type(key_type, next(iter(item.keys()))) and validate_item_type(
+                value_type, next(iter(item.values()))
+            )
         return isinstance(item, type_in)
 
     test_object = test_class(*args)
@@ -464,9 +496,19 @@ def test_basic() -> None:
         e: Optional[uint32]
         f: Optional[uint32]
         g: tuple[uint32, str, bytes]
+        h: dict[uint32, str]
 
     # we want to test invalid here, hence the ignore.
-    a = TestClass(24, 352, [1, 2, 4], [[1, 2, 3], [3, 4]], 728, None, (383, "hello", b"goodbye"))  # type: ignore[arg-type,list-item]
+    a = TestClass(
+        uint32(24),
+        uint32(352),
+        [uint32(1), uint32(2), uint32(4)],
+        [[uint32(1), uint32(2), uint32(3)], [uint32(3), uint32(4)]],
+        uint32(728),
+        None,
+        (uint32(383), "hello", b"goodbye"),
+        {uint32(1): "foo"},
+    )
 
     b: bytes = bytes(a)
     assert a == TestClass.from_bytes(b)
@@ -801,7 +843,7 @@ class TestFromBytes:
 class FailFromBytes:
     @classmethod
     def from_bytes(cls, b: bytes) -> FailFromBytes:
-        raise ValueError()
+        raise ValueError
 
 
 def test_parse_str() -> None:
@@ -869,10 +911,8 @@ def test_streamable_inheritance_missing() -> None:
     [
         (function_to_parse_one_item, float),
         (function_to_parse_one_item, int),
-        (function_to_parse_one_item, dict),
         (function_to_stream_one_item, float),
         (function_to_stream_one_item, int),
-        (function_to_stream_one_item, dict),
         (recurse_jsonify, 1.0),
         (recurse_jsonify, recurse_jsonify),
     ],
@@ -880,3 +920,22 @@ def test_streamable_inheritance_missing() -> None:
 def test_unsupported_types(method: Callable[[object], object], input_type: object) -> None:
     with pytest.raises(UnsupportedType):
         method(input_type)
+
+
+@streamable
+@dataclass(frozen=True)
+class UnsupportedDictToSerialize(Streamable):
+    a: list[tuple[str, uint8]]
+
+
+@streamable
+@dataclass(frozen=True)
+class UnsupportedDictToDeserialize(Streamable):
+    a: dict[str, uint8]
+
+
+def test_duplicate_dict_key_error() -> None:
+    with pytest.raises(ValueError, match="duplicate dict keys"):
+        UnsupportedDictToDeserialize.from_bytes(
+            bytes(UnsupportedDictToSerialize([("foo", uint8(1)), ("foo", uint8(2))]))
+        )

chia/_tests/db/test_db_wrapper.py

@@ -24,8 +24,6 @@ if TYPE_CHECKING:
 class UniqueError(Exception):
     """Used to uniquely trigger the exception path out of the context managers."""
 
-    pass
-
 
 async def increment_counter(db_wrapper: DBWrapper2) -> None:
     async with db_wrapper.writer_maybe_transaction() as connection:
@@ -427,7 +425,7 @@ async def test_cancelled_reader_does_not_cancel_writer() -> None:
 
             with pytest.raises(UniqueError):
                 async with db_wrapper.reader() as _:
-                    raise UniqueError()
+                    raise UniqueError
 
             assert await query_value(connection=writer) == 1
 

chia/_tests/environments/wallet.py

@@ -14,10 +14,8 @@ from chia_rs.sized_ints import uint32, uint64
 from chia._tests.environments.common import ServiceEnvironment
 from chia.cmds.cmd_helpers import NeedsTXConfig, NeedsWalletRPC, TransactionEndpoint, TransactionsOut, WalletClientInfo
 from chia.cmds.param_types import CliAmount, cli_amount_none
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 from chia.rpc.rpc_server import RpcServer
-from chia.rpc.wallet_rpc_api import WalletRpcApi
-from chia.rpc.wallet_rpc_client import WalletRpcClient
 from chia.server.server import ChiaServer
 from chia.server.start_service import Service
 from chia.simulator.full_node_simulator import FullNodeSimulator
@@ -27,6 +25,8 @@ from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_node import Balance, WalletNode
 from chia.wallet.wallet_node_api import WalletNodeAPI
+from chia.wallet.wallet_rpc_api import WalletRpcApi
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 from chia.wallet.wallet_state_manager import WalletStateManager
 
 STANDARD_TX_ENDPOINT_ARGS: dict[str, Any] = TransactionEndpoint(
@@ -355,7 +355,7 @@ class WalletTestFramework:
             for env in self.environments:
                 ph_indexes: dict[uint32, int] = {}
                 for wallet_id in env.wallet_state_manager.wallets:
-                    ph_indexes[wallet_id] = await env.wallet_state_manager.puzzle_store.get_unused_count(wallet_id)
+                    ph_indexes[wallet_id] = await env.wallet_state_manager.puzzle_store.get_used_count(wallet_id)
                 puzzle_hash_indexes.append(ph_indexes)
 
         pending_txs: list[list[LightTransactionRecord]] = []
@@ -426,5 +426,5 @@ class WalletTestFramework:
             for env, ph_indexes_before in zip(self.environments, puzzle_hash_indexes):
                 for wallet_id, ph_index in zip(env.wallet_state_manager.wallets, ph_indexes_before):
                     assert ph_indexes_before[wallet_id] == (
-                        await env.wallet_state_manager.puzzle_store.get_unused_count(wallet_id)
+                        await env.wallet_state_manager.puzzle_store.get_used_count(wallet_id)
                     )

chia/_tests/farmer_harvester/test_farmer.py

@@ -9,10 +9,11 @@ from typing import Any, Optional, Union, cast
 from unittest.mock import ANY
 
 import pytest
-from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 from pytest_mock import MockerFixture
+from typing_extensions import Self
 from yarl import URL
 
 from chia import __version__
@@ -24,11 +25,10 @@ from chia.pools.pool_config import PoolWalletConfig
 from chia.protocols import farmer_protocol, harvester_protocol
 from chia.protocols.harvester_protocol import NewProofOfSpace, RespondSignatures
 from chia.protocols.pool_protocol import PoolErrorCode
+from chia.server.aliases import FarmerService, HarvesterService
 from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.block_tools import BlockTools
-from chia.types.aliases import FarmerService, HarvesterService
 from chia.types.blockchain_format.proof_of_space import (
-    ProofOfSpace,
     generate_plot_public_key,
     verify_and_get_quality_string,
 )
@@ -571,13 +571,14 @@ async def test_farmer_new_proof_of_space_for_pool_stats(
         sub_slot_iters=case.sub_slot_iters,
         signage_point_index=case.signage_point_index,
         peak_height=uint32(1),
+        last_tx_height=uint32(0),
     )
     pos = ProofOfSpace(
         challenge=case.plot_challenge,
         pool_public_key=case.pool_public_key,
         pool_contract_puzzle_hash=case.pool_contract_puzzle_hash,
         plot_public_key=case.plot_public_key,
-        size=case.plot_size,
+        version_and_size=case.plot_size,
         proof=case.proof,
     )
     new_pos = NewProofOfSpace(
@@ -680,7 +681,7 @@ class DummyPoolResponse:
 
         return json.dumps(json_dict)
 
-    async def __aenter__(self) -> DummyPoolResponse:
+    async def __aenter__(self) -> Self:
         return self
 
     async def __aexit__(
@@ -711,13 +712,14 @@ def create_valid_pos(farmer: Farmer) -> tuple[farmer_protocol.NewSignagePoint, P
         sub_slot_iters=case.sub_slot_iters,
         signage_point_index=case.signage_point_index,
         peak_height=uint32(1),
+        last_tx_height=uint32(0),
     )
     pos = ProofOfSpace(
         challenge=case.plot_challenge,
         pool_public_key=case.pool_public_key,
         pool_contract_puzzle_hash=case.pool_contract_puzzle_hash,
         plot_public_key=case.plot_public_key,
-        size=case.plot_size,
+        version_and_size=case.plot_size,
         proof=case.proof,
     )
     new_pos = NewProofOfSpace(
@@ -1003,7 +1005,7 @@ class DummyPoolInfoResponse:
 
         return json.dumps(self.pool_info)
 
-    async def __aenter__(self) -> DummyPoolInfoResponse:
+    async def __aenter__(self) -> Self:
         return self
 
     async def __aexit__(

chia/_tests/farmer_harvester/test_farmer_harvester.py

@@ -15,13 +15,13 @@ from chia._tests.util.split_managers import split_async_manager
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.cmds.cmds_util import get_any_service_client
 from chia.farmer.farmer import Farmer
+from chia.harvester.harvester_rpc_client import HarvesterRpcClient
 from chia.plotting.util import PlotsRefreshParameter
 from chia.protocols import farmer_protocol, harvester_protocol
+from chia.protocols.outbound_message import NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.rpc.harvester_rpc_client import HarvesterRpcClient
-from chia.server.outbound_message import NodeType, make_msg
+from chia.server.aliases import FarmerService, HarvesterService
 from chia.simulator.block_tools import BlockTools
-from chia.types.aliases import FarmerService, HarvesterService
 from chia.types.peer_info import UnresolvedPeerInfo
 from chia.util.config import load_config
 from chia.util.hash import std_hash
@@ -221,7 +221,14 @@ async def test_missing_signage_point(
     def create_sp(index: int, challenge_hash: bytes32) -> tuple[uint64, farmer_protocol.NewSignagePoint]:
         time = uint64(index + 1)
         sp = farmer_protocol.NewSignagePoint(
-            challenge_hash, std_hash(b"2"), std_hash(b"3"), uint64(1), uint64(1000000), uint8(index), uint32(1)
+            challenge_hash,
+            std_hash(b"2"),
+            std_hash(b"3"),
+            uint64(1),
+            uint64(1000000),
+            uint8(index),
+            uint32(1),
+            uint32(0),
         )
         return time, sp
 

chia/_tests/farmer_harvester/test_filter_prefix_bits.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Any, Optional
 
 import pytest
+from chia_rs import FullBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
@@ -13,13 +14,12 @@ from chia._tests.core.test_farmer_harvester_rpc import wait_for_plot_sync
 from chia._tests.util.setup_nodes import setup_farmer_multi_harvester
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.farmer.farmer_api import FarmerAPI
+from chia.farmer.farmer_rpc_client import FarmerRpcClient
+from chia.harvester.harvester_rpc_client import HarvesterRpcClient
 from chia.protocols import farmer_protocol
-from chia.rpc.farmer_rpc_client import FarmerRpcClient
-from chia.rpc.harvester_rpc_client import HarvesterRpcClient
+from chia.server.aliases import HarvesterService
 from chia.simulator.block_tools import create_block_tools_async, test_constants
-from chia.types.aliases import HarvesterService
 from chia.types.blockchain_format.proof_of_space import get_plot_id, passes_plot_filter
-from chia.types.full_block import FullBlock
 from chia.util.keychain import Keychain
 
 
@@ -56,7 +56,7 @@ async def farmer_harvester_with_filter_size_9(
         return len(await farmer_rpc_cl.get_connections()) > 0
 
     local_b_tools = await create_block_tools_async(
-        constants=test_constants.replace(NUMBER_ZERO_BITS_PLOT_FILTER=uint8(9)), keychain=get_temp_keyring
+        constants=test_constants.replace(NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(9)), keychain=get_temp_keyring
     )
     new_config = local_b_tools._config
     local_b_tools.change_config(new_config)
@@ -121,6 +121,7 @@ async def test_filter_prefix_bits_with_farmer_harvester(
         sub_slot_iters=uint64(1000000),
         signage_point_index=uint8(2),
         peak_height=peak_height,
+        last_tx_height=uint32(0),
     )
     await farmer_api.new_signage_point(sp)
     await time_out_assert(5, state_has_changed, True)

chia/_tests/farmer_harvester/test_third_party_harvesters.py

@@ -10,12 +10,21 @@ from os.path import dirname
 from typing import Optional, Union, cast
 
 import pytest
-from chia_rs import FoliageBlockData, FoliageTransactionBlock, G1Element
+from chia_rs import (
+    ChallengeChainSubSlot,
+    FoliageBlockData,
+    FoliageTransactionBlock,
+    FullBlock,
+    G1Element,
+    ProofOfSpace,
+    RewardChainSubSlot,
+)
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia._tests.util.misc import patch_request_handler
 from chia._tests.util.time_out_assert import time_out_assert
+from chia.consensus.augmented_chain import AugmentedBlockchain
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.blockchain import AddBlockResult
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
@@ -28,20 +37,16 @@ from chia.harvester.harvester import Harvester
 from chia.harvester.harvester_api import HarvesterAPI
 from chia.protocols import farmer_protocol, full_node_protocol, harvester_protocol, timelord_protocol
 from chia.protocols.harvester_protocol import ProofOfSpaceFeeInfo, RespondSignatures, SigningDataKind
+from chia.protocols.outbound_message import Message, NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.server.outbound_message import Message, NodeType, make_msg
+from chia.server.aliases import FarmerService, FullNodeService, HarvesterService
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.start_simulator import SimulatorFullNodeService
-from chia.types.aliases import FarmerService, FullNodeService, HarvesterService
 from chia.types.blockchain_format.classgroup import ClassgroupElement
-from chia.types.blockchain_format.proof_of_space import ProofOfSpace
-from chia.types.blockchain_format.slots import ChallengeChainSubSlot, RewardChainSubSlot
-from chia.types.full_block import FullBlock
 from chia.types.peer_info import UnresolvedPeerInfo
 from chia.types.validation_state import ValidationState
-from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.bech32m import decode_puzzle_hash
 from chia.util.hash import std_hash
 
@@ -72,7 +77,6 @@ async def test_harvester_receive_source_signing_data(
         full_node_service_2,
         _,
     ) = farmer_harvester_2_simulators_zero_bits_plot_filter
-
     farmer: Farmer = farmer_service._node
     harvester: Harvester = harvester_service._node
     full_node_1: FullNode = full_node_service_1._node
@@ -101,6 +105,7 @@ async def test_harvester_receive_source_signing_data(
     # so that we have blocks generated that have our farmer reward address, instead
     # of the GENESIS_PRE_FARM_FARMER_PUZZLE_HASH.
     await add_test_blocks_into_full_node(blocks, full_node_2)
+    await time_out_assert(60, full_node_2.blockchain.get_peak_height, blocks[-1].height)
 
     validated_foliage_data = False
     validated_foliage_transaction = False
@@ -359,6 +364,7 @@ def prepare_sp_and_pos_for_fee_test(
         sub_slot_iters=uint64(0),
         signage_point_index=uint8(0),
         peak_height=uint32(1),
+        last_tx_height=uint32(0),
     )
 
     pos = harvester_protocol.NewProofOfSpace(
@@ -370,7 +376,7 @@ def prepare_sp_and_pos_for_fee_test(
             pool_public_key=None,
             pool_contract_puzzle_hash=None,
             plot_public_key=pubkey,
-            size=uint8(len(proof)),
+            version_and_size=uint8(32),
             proof=proof,
         ),
         signage_point_index=uint8(0),

chia/_tests/fee_estimation/test_fee_estimation_integration.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import types
 
 import pytest
-from chia_rs import Coin
+from chia_rs import Coin, SpendBundleConditions, SpendConditions
 from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.core.mempool.test_mempool_manager import (
@@ -28,7 +28,6 @@ from chia.simulator.wallet_tools import WalletTool
 from chia.types.clvm_cost import CLVMCost
 from chia.types.fee_rate import FeeRate, FeeRateV2
 from chia.types.mempool_item import MempoolItem
-from chia.types.spend_bundle_conditions import SpendBundleConditions, SpendConditions
 
 
 def make_mempoolitem() -> MempoolItem:

chia/_tests/fee_estimation/test_fee_estimation_rpc.py

@@ -4,19 +4,20 @@ import re
 from typing import Any
 
 import pytest
+from chia_rs import SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
-from chia.rpc.full_node_rpc_api import FullNodeRpcApi
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.full_node.full_node_rpc_api import FullNodeRpcApi
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
+from chia.server.aliases import WalletService
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
 from chia.simulator.start_simulator import SimulatorFullNodeService
 from chia.simulator.wallet_tools import WalletTool
-from chia.types.aliases import WalletService
 from chia.types.blockchain_format.coin import Coin
-from chia.types.spend_bundle import SpendBundle
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 
 
 @pytest.fixture(scope="function")
@@ -37,7 +38,8 @@ async def setup_node_and_rpc(
     )
     full_node_rpc_api = FullNodeRpcApi(full_node_api.full_node)
 
-    ph = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
 
     for i in range(4):
         await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))

chia/_tests/fee_estimation/test_fee_estimation_unit_tests.py

@@ -80,7 +80,7 @@ def test_steady_fee_pressure() -> None:
         estimation = estimator.estimate_fee_rate(time_offset_seconds=time_offset_seconds * (height - start_from))
         estimates_after.append(estimation)
 
-    block_estimates = [estimator.estimate_fee_rate_for_block(uint32(h + 1)) for h in range(0, 50)]
+    block_estimates = [estimator.estimate_fee_rate_for_block(uint32(h + 1)) for h in range(50)]
     for idx, es_after in enumerate(estimates_after):
         assert abs(es_after.mojos_per_clvm_cost - estimates_during[idx].mojos_per_clvm_cost) < 0.001
         assert es_after.mojos_per_clvm_cost == block_estimates[idx].mojos_per_clvm_cost

chia/_tests/generator/test_compression.py

@@ -12,14 +12,13 @@ from chia_puzzles_py.programs import (
     DECOMPRESS_PUZZLE,
     ROM_BOOTSTRAP_GENERATOR,
 )
-from chia_rs import serialized_length
+from chia_rs import SpendBundle, serialized_length
 from chia_rs.sized_ints import uint32
 from clvm.serialize import sexp_from_stream
 from clvm.SExp import SExp
 from clvm_tools import binutils
 
 from chia.types.blockchain_format.program import INFINITE_COST, Program
-from chia.types.spend_bundle import SpendBundle
 from chia.util.byte_types import hexstr_to_bytes
 from chia.wallet.puzzles.load_clvm import load_clvm
 

chia/_tests/generator/test_rom.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from chia_puzzles_py.programs import CHIALISP_DESERIALISATION, ROM_BOOTSTRAP_GENERATOR
+from chia_rs import SpendConditions
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 from clvm.CLVMObject import CLVMStorage
@@ -10,10 +11,9 @@ from clvm_tools.clvmc import compile_clvm_text
 from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia.consensus.condition_costs import ConditionCost
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.program import Program, run_with_cost
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.generator_types import BlockGenerator
-from chia.types.spend_bundle_conditions import SpendConditions
 
 DESERIALIZE_MOD = Program.from_bytes(CHIALISP_DESERIALISATION)
 
@@ -77,7 +77,7 @@ EXPECTED_OUTPUT = (
 def run_generator(self: BlockGenerator) -> tuple[int, Program]:
     """This mode is meant for accepting possibly soft-forked transactions into the mempool"""
     args = Program.to([self.generator_refs])
-    return GENERATOR_MOD.run_with_cost(MAX_COST, [self.program, args])
+    return run_with_cost(GENERATOR_MOD, MAX_COST, [self.program, args])
 
 
 def as_atom_list(prg: CLVMStorage) -> list[bytes]:
@@ -110,7 +110,7 @@ class TestROM:
 
         args = Program.to([DESERIALIZE_MOD, [FIRST_GENERATOR, SECOND_GENERATOR]])
         sp = to_sp(COMPILED_GENERATOR_CODE)
-        cost, r = sp.run_with_cost(MAX_COST, args)
+        cost, r = run_with_cost(sp, MAX_COST, args)
         assert cost == EXPECTED_ABBREVIATED_COST
         assert r.as_bin().hex() == EXPECTED_OUTPUT
 
@@ -155,6 +155,10 @@ class TestROM:
             agg_sig_parent_amount=[],
             agg_sig_parent_puzzle=[],
             flags=0,
+            # in run_block_generator() we don't have access to separate
+            # execution cost, just in run_block_generator2()
+            execution_cost=0 if softfork_height < DEFAULT_CONSTANTS.HARD_FORK_HEIGHT else 44,
+            condition_cost=1800000,
         )
 
         assert npc_result.conds.spends == [spend]

chia/_tests/plot_sync/test_plot_sync.py

@@ -29,8 +29,8 @@ from chia.plotting.manager import PlotManager
 from chia.plotting.util import add_plot_directory, remove_plot_directory
 from chia.protocols.harvester_protocol import Plot
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.aliases import FarmerService, HarvesterService
 from chia.simulator.block_tools import BlockTools
-from chia.types.aliases import FarmerService, HarvesterService
 from chia.util.config import create_default_chia_config, lock_and_load_config, save_config
 from chia.util.streamable import _T_Streamable
 
@@ -537,7 +537,7 @@ async def test_farmer_restart(environment: Environment) -> None:
     # Load all directories for both harvesters
     await add_and_validate_all_directories(env)
     last_sync_ids: list[uint64] = []
-    for i in range(0, len(env.harvesters)):
+    for i in range(len(env.harvesters)):
         last_sync_ids.append(env.harvesters[i].plot_sync_sender._last_sync_id)
     # Stop the farmer and make sure both receivers get dropped and refreshing gets stopped on the harvesters
     await env.split_farmer_service_manager.exit()
@@ -551,7 +551,7 @@ async def test_farmer_restart(environment: Environment) -> None:
         assert len(env.farmer.plot_sync_receivers) == 2
         # Do not use run_sync_test here, to have a more realistic test scenario just
         # wait for the harvesters to be synced.  The handshake should trigger re-sync.
-        for i in range(0, len(env.harvesters)):
+        for i in range(len(env.harvesters)):
             harvester: Harvester = env.harvesters[i]
             assert harvester.server is not None
             receiver = env.farmer.plot_sync_receivers[harvester.server.node_id]

chia/_tests/plot_sync/test_receiver.py

@@ -26,7 +26,7 @@ from chia.protocols.harvester_protocol import (
     PlotSyncResponse,
     PlotSyncStart,
 )
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
 from chia.util.streamable import _T_Streamable
 
 log = logging.getLogger(__name__)
@@ -137,7 +137,7 @@ async def run_sync_step(receiver: Receiver, sync_step: SyncStepData) -> None:
         assert len(step_data) == 10
         # Invoke batches of: 1, 2, 3, 4 items and validate the data against plot store before and after
         indexes = [0, 1, 3, 6, 10]
-        for i in range(0, len(indexes) - 1):
+        for i in range(len(indexes) - 1):
             plots_processed_before = receiver.current_sync().plots_processed
             invoke_data = step_data[indexes[i] : indexes[i + 1]]
             pre_function_validate(receiver, invoke_data, sync_step.state)
@@ -166,7 +166,7 @@ def plot_sync_setup(seeded_random: random.Random) -> tuple[Receiver, list[SyncSt
     receiver = Receiver(harvester_connection, dummy_callback)  # type:ignore[arg-type]
 
     # Create example plot data
-    path_list = [str(x) for x in range(0, 40)]
+    path_list = [str(x) for x in range(40)]
     plot_info_list = [
         Plot(
             filename=str(x),