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

chia/_tests/wallet/clawback/test_clawback_lifecycle.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Dict, Optional, Tuple
+from typing import Optional
 
 import pytest
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
@@ -8,8 +8,8 @@ from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
 from chia._tests.clvm.benchmark_costs import cost_of_spend_bundle
 from chia._tests.clvm.test_puzzles import public_key_for_index, secret_exponent_for_index
 from chia._tests.util.key_tool import KeyTool
+from chia._tests.util.spend_sim import CostLogger, SimClient, SpendSim, sim_and_client
 from chia._tests.util.time_out_assert import time_out_assert
-from chia.clvm.spend_sim import CostLogger, SimClient, SpendSim, sim_and_client
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.program import INFINITE_COST, Program
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -48,7 +48,7 @@ async def do_spend(
     sim: SpendSim,
     sim_client: SimClient,
     spend_bundle: WalletSpendBundle,
-    expected_result: Tuple[MempoolInclusionStatus, Optional[Err]],
+    expected_result: tuple[MempoolInclusionStatus, Optional[Err]],
     cost_logger: Optional[CostLogger] = None,
     cost_log_msg: str = "",
 ) -> int:
@@ -66,7 +66,7 @@ async def do_spend(
 class TestClawbackLifecycle:
     # Helper function
     def sign_coin_spend(self, coin_spend: CoinSpend, index: int) -> G2Element:
-        synthetic_secret_key: PrivateKey = calculate_synthetic_secret_key(  # noqa
+        synthetic_secret_key: PrivateKey = calculate_synthetic_secret_key(
             PrivateKey.from_bytes(
                 secret_exponent_for_index(index).to_bytes(32, "big"),
             ),
@@ -277,7 +277,7 @@ class TestClawbackLifecycle:
         cb_sender_sol = create_merkle_solution(timelock, sender_ph, recipient_ph, sender_puz, sender_sol)
 
         conds = conditions_dict_for_solution(clawback_puz, cb_sender_sol, INFINITE_COST)
-        assert isinstance(conds, Dict)
+        assert isinstance(conds, dict)
         create_coins = conds[ConditionOpcode.CREATE_COIN]
         assert len(create_coins) == 1
         assert create_coins[0].vars[0] == sender_ph
@@ -286,7 +286,7 @@ class TestClawbackLifecycle:
         cb_recipient_sol = create_merkle_solution(timelock, sender_ph, recipient_ph, recipient_puz, recipient_sol)
         clawback_puz.run(cb_recipient_sol)
         conds = conditions_dict_for_solution(clawback_puz, cb_recipient_sol, INFINITE_COST)
-        assert isinstance(conds, Dict)
+        assert isinstance(conds, dict)
         create_coins = conds[ConditionOpcode.CREATE_COIN]
         assert len(create_coins) == 1
         assert create_coins[0].vars[0] == recipient_ph

chia/_tests/wallet/clawback/test_clawback_metadata.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import random
-from typing import List, Tuple
 
 import pytest
 
@@ -21,7 +20,7 @@ from chia.wallet.wallet_node import WalletNode
 )
 @pytest.mark.anyio
 async def test_is_recipient(
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
     trusted: bool,
     self_hostname: str,
     seeded_random: random.Random,

chia/_tests/wallet/conftest.py

@@ -1,20 +1,30 @@
 from __future__ import annotations
 
+import contextlib
+import unittest
+from collections.abc import AsyncIterator, Awaitable
 from contextlib import AsyncExitStack
 from dataclasses import replace
-from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Literal, Optional, Tuple
+from typing import Any, Callable, Literal, Optional
 
 import pytest
+from chia_rs import (
+    DONT_VALIDATE_SIGNATURE,
+    SpendBundleConditions,
+    get_flags_for_height_and_constants,
+    run_block_generator,
+    run_block_generator2,
+)
 
-from chia._tests.environments.wallet import WalletEnvironment, WalletState, WalletTestFramework
+from chia._tests.environments.wallet import NewPuzzleHashError, WalletEnvironment, WalletState, WalletTestFramework
 from chia._tests.util.setup_nodes import setup_simulators_and_wallets_service
 from chia._tests.wallet.wallet_block_tools import WalletBlockTools
 from chia.consensus.constants import ConsensusConstants
-from chia.consensus.cost_calculator import NPCResult
 from chia.full_node.full_node import FullNode
 from chia.rpc.full_node_rpc_client import FullNodeRpcClient
 from chia.rpc.wallet_rpc_client import WalletRpcClient
 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.util.ints import uint32, uint64, uint128
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
@@ -55,8 +65,8 @@ async def ignore_block_validation(
     if "standard_block_tools" in request.keywords:
         return None
 
-    async def validate_block_body(*args: Any, **kwargs: Any) -> Tuple[Literal[None], NPCResult]:
-        return None, args[7]
+    async def validate_block_body(*args: Any, **kwargs: Any) -> Literal[None]:
+        return None
 
     def create_wrapper(original_create: Any) -> Any:
         async def new_create(*args: Any, **kwargs: Any) -> Any:
@@ -73,9 +83,34 @@ async def ignore_block_validation(
 
         return new_create
 
+    def run_block(
+        block: FullBlock, prev_generators: list[bytes], constants: ConsensusConstants
+    ) -> tuple[Optional[int], Optional[SpendBundleConditions]]:
+        assert block.transactions_generator is not None
+        assert block.transactions_info is not None
+        flags = get_flags_for_height_and_constants(block.height, constants) | DONT_VALIDATE_SIGNATURE
+        if block.height >= constants.HARD_FORK_HEIGHT:
+            run_block = run_block_generator2
+        else:
+            run_block = run_block_generator
+        err, conds = run_block(
+            bytes(block.transactions_generator),
+            prev_generators,
+            block.transactions_info.cost,
+            flags,
+            block.transactions_info.aggregated_signature,
+            None,
+            constants,
+        )
+        # pretend that the signatures are OK
+        if conds is not None:
+            conds = conds.replace(validated_signature=True)
+        return err, conds
+
     monkeypatch.setattr("chia.simulator.block_tools.BlockTools", WalletBlockTools)
     monkeypatch.setattr(FullNode, "create", create_wrapper(FullNode.create))
     monkeypatch.setattr("chia.consensus.blockchain.validate_block_body", validate_block_body)
+    monkeypatch.setattr("chia.consensus.multiprocess_validation._run_block", run_block)
     monkeypatch.setattr(
         "chia.consensus.block_header_validation.validate_unfinished_header_block", lambda *_, **__: (uint64(1), None)
     )
@@ -86,7 +121,7 @@ async def ignore_block_validation(
         "chia.consensus.multiprocess_validation.validate_finished_header_block", lambda *_, **__: (uint64(1), None)
     )
     monkeypatch.setattr(
-        "chia.consensus.multiprocess_validation.verify_and_get_quality_string", lambda *_, **__: bytes32([0] * 32)
+        "chia.consensus.multiprocess_validation.verify_and_get_quality_string", lambda *_, **__: bytes32.zeros
     )
     monkeypatch.setattr("chia.consensus.block_record.BlockRecord.sp_total_iters", lambda *_: uint128(0))
     monkeypatch.setattr("chia.consensus.block_record.BlockRecord.ip_sub_slot_total_iters", lambda *_: uint128(0))
@@ -111,6 +146,28 @@ def tx_config(request: Any) -> TXConfig:
     return replace(DEFAULT_TX_CONFIG, reuse_puzhash=request.param)
 
 
+def new_action_scope_wrapper(func: Any) -> Any:
+    @contextlib.asynccontextmanager
+    async def wrapped_new_action_scope(self: WalletStateManager, *args: Any, **kwargs: Any) -> Any:
+        # Take note of the number of puzzle hashes if we're supposed to be reusing
+        ph_indexes: dict[uint32, int] = {}
+        for wallet_id in self.wallets:
+            ph_indexes[wallet_id] = await self.puzzle_store.get_unused_count(wallet_id)
+
+        async with func(self, *args, **kwargs) as action_scope:
+            yield action_scope
+
+        # Finally, check that the number of puzzle hashes did or did not increase by the specified amount
+        if action_scope.config.tx_config.reuse_puzhash:
+            for wallet_id, ph_index in zip(self.wallets, ph_indexes):
+                if not ph_indexes[wallet_id] == (await self.puzzle_store.get_unused_count(wallet_id)):
+                    raise NewPuzzleHashError(
+                        f"wallet ID {wallet_id} generated new puzzle hashes while reuse_puzhash was False"
+                    )
+
+    return wrapped_new_action_scope
+
+
 # This fixture automatically creates 4 parametrized tests trusted/untrusted x reuse/new derivations
 # These parameterizations can be skipped by manually specifying "trusted" or "reuse puzhash" to the fixture
 @pytest.fixture(scope="function")
@@ -128,7 +185,7 @@ async def wallet_environments(
             pytest.skip("Skipping not specified reuse_puzhash mode")
     assert len(request.param["blocks_needed"]) == request.param["num_environments"]
     if "config_overrides" in request.param:
-        config_overrides: Dict[str, Any] = request.param["config_overrides"]
+        config_overrides: dict[str, Any] = request.param["config_overrides"]
     else:  # pragma: no cover
         config_overrides = {}
     async with setup_simulators_and_wallets_service(
@@ -141,77 +198,81 @@ async def wallet_environments(
 
         full_node[0]._api.full_node.config = {**full_node[0]._api.full_node.config, **config_overrides}
 
-        wallet_rpc_clients: List[WalletRpcClient] = []
-        async with AsyncExitStack() as astack:
-            for service in wallet_services:
-                service._node.config = {
-                    **service._node.config,
-                    "trusted_peers": (
-                        {full_node[0]._api.server.node_id.hex(): full_node[0]._api.server.node_id.hex()}
-                        if trusted_full_node
-                        else {}
-                    ),
-                    **config_overrides,
-                }
-                service._node.wallet_state_manager.config = service._node.config
-                # Shorten the 10 seconds default value
-                service._node.coin_state_retry_seconds = 2
-                await service._node.server.start_client(
-                    PeerInfo(bt.config["self_hostname"], full_node[0]._api.full_node.server.get_port()), None
-                )
-                wallet_rpc_clients.append(
-                    await astack.enter_async_context(
-                        WalletRpcClient.create_as_context(
-                            bt.config["self_hostname"],
-                            # Semantics guarantee us a non-None value here
-                            service.rpc_server.listen_port,  # type: ignore[union-attr]
-                            service.root_path,
-                            service.config,
+        new_action_scope_wrapped = new_action_scope_wrapper(WalletStateManager.new_action_scope)
+        with unittest.mock.patch(
+            "chia.wallet.wallet_state_manager.WalletStateManager.new_action_scope", new=new_action_scope_wrapped
+        ):
+            wallet_rpc_clients: list[WalletRpcClient] = []
+            async with AsyncExitStack() as astack:
+                for service in wallet_services:
+                    service._node.config = {
+                        **service._node.config,
+                        "trusted_peers": (
+                            {full_node[0]._api.server.node_id.hex(): full_node[0]._api.server.node_id.hex()}
+                            if trusted_full_node
+                            else {}
+                        ),
+                        **config_overrides,
+                    }
+                    service._node.wallet_state_manager.config = service._node.config
+                    # Shorten the 10 seconds default value
+                    service._node.coin_state_retry_seconds = 2
+                    await service._node.server.start_client(
+                        PeerInfo(bt.config["self_hostname"], full_node[0]._api.full_node.server.get_port()), None
+                    )
+                    wallet_rpc_clients.append(
+                        await astack.enter_async_context(
+                            WalletRpcClient.create_as_context(
+                                bt.config["self_hostname"],
+                                # Semantics guarantee us a non-None value here
+                                service.rpc_server.listen_port,  # type: ignore[union-attr]
+                                service.root_path,
+                                service.config,
+                            )
                         )
                     )
-                )
 
-            wallet_states: List[WalletState] = []
-            for service, blocks_needed in zip(wallet_services, request.param["blocks_needed"]):
-                if blocks_needed > 0:
-                    await full_node[0]._api.farm_blocks_to_wallet(
-                        count=blocks_needed, wallet=service._node.wallet_state_manager.main_wallet
+                wallet_states: list[WalletState] = []
+                for service, blocks_needed in zip(wallet_services, request.param["blocks_needed"]):
+                    if blocks_needed > 0:
+                        await full_node[0]._api.farm_blocks_to_wallet(
+                            count=blocks_needed, wallet=service._node.wallet_state_manager.main_wallet
+                        )
+                        await full_node[0]._api.wait_for_wallet_synced(wallet_node=service._node, timeout=20)
+                    wallet_states.append(
+                        WalletState(
+                            Balance(
+                                confirmed_wallet_balance=uint128(2_000_000_000_000 * blocks_needed),
+                                unconfirmed_wallet_balance=uint128(2_000_000_000_000 * blocks_needed),
+                                spendable_balance=uint128(2_000_000_000_000 * blocks_needed),
+                                pending_change=uint64(0),
+                                max_send_amount=uint128(2_000_000_000_000 * blocks_needed),
+                                unspent_coin_count=uint32(2 * blocks_needed),
+                                pending_coin_removal_count=uint32(0),
+                            ),
+                        )
                     )
-                    await full_node[0]._api.wait_for_wallet_synced(wallet_node=service._node, timeout=20)
-                wallet_states.append(
-                    WalletState(
-                        Balance(
-                            confirmed_wallet_balance=uint128(2_000_000_000_000 * blocks_needed),
-                            unconfirmed_wallet_balance=uint128(2_000_000_000_000 * blocks_needed),
-                            spendable_balance=uint128(2_000_000_000_000 * blocks_needed),
-                            pending_change=uint64(0),
-                            max_send_amount=uint128(2_000_000_000_000 * blocks_needed),
-                            unspent_coin_count=uint32(2 * blocks_needed),
-                            pending_coin_removal_count=uint32(0),
-                        ),
+
+                assert full_node[0].rpc_server is not None
+                client_node = await astack.enter_async_context(
+                    FullNodeRpcClient.create_as_context(
+                        bt.config["self_hostname"],
+                        full_node[0].rpc_server.listen_port,
+                        full_node[0].root_path,
+                        full_node[0].config,
                     )
                 )
-
-            assert full_node[0].rpc_server is not None
-            client_node = await astack.enter_async_context(
-                FullNodeRpcClient.create_as_context(
-                    bt.config["self_hostname"],
-                    full_node[0].rpc_server.listen_port,
-                    full_node[0].root_path,
-                    full_node[0].config,
+                yield WalletTestFramework(
+                    full_node[0]._api,
+                    client_node,
+                    trusted_full_node,
+                    [
+                        WalletEnvironment(
+                            service=service,
+                            rpc_client=rpc_client,
+                            wallet_states={uint32(1): wallet_state},
+                        )
+                        for service, rpc_client, wallet_state in zip(wallet_services, wallet_rpc_clients, wallet_states)
+                    ],
+                    tx_config,
                 )
-            )
-            yield WalletTestFramework(
-                full_node[0]._api,
-                client_node,
-                trusted_full_node,
-                [
-                    WalletEnvironment(
-                        service=service,
-                        rpc_client=rpc_client,
-                        wallet_states={uint32(1): wallet_state},
-                    )
-                    for service, rpc_client, wallet_state in zip(wallet_services, wallet_rpc_clients, wallet_states)
-                ],
-                tx_config,
-            )

chia/_tests/wallet/dao_wallet/test_dao_clvm.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-from typing import Any, List, Optional, Tuple
+from typing import Any, Optional
 
 import pytest
 from chia_rs import AugSchemeMPL
 from clvm.casts import int_to_bytes
 
-from chia.clvm.spend_sim import SimClient, SpendSim, sim_and_client
+from chia._tests.util.spend_sim import SimClient, SpendSim, sim_and_client
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import INFINITE_COST, Program
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -537,12 +537,16 @@ def test_validator() -> None:
 
     # Setup the spend_p2_singleton (proposal inner puz)
     spend_p2_singleton = SPEND_P2_SINGLETON_MOD.curry(
-        treasury_struct, CAT_MOD_HASH, conditions, [], p2_singleton_puzhash  # tailhash conds
+        treasury_struct,
+        CAT_MOD_HASH,
+        conditions,
+        [],
+        p2_singleton_puzhash,  # tailhash conds
     )
     spend_p2_singleton_puzhash = spend_p2_singleton.get_tree_hash()
 
     parent_amt_list = [[parent_id, locked_amount]]
-    cat_parent_amt_list: List[Optional[Any]] = []
+    cat_parent_amt_list: list[Optional[Any]] = []
     spend_p2_singleton_solution = Program.to([parent_amt_list, cat_parent_amt_list, treasury_inner.get_tree_hash()])
 
     output_conds = spend_p2_singleton.run(spend_p2_singleton_solution)
@@ -592,8 +596,6 @@ def test_validator() -> None:
     conds = proposal_validator.run(solution)
     assert len(conds.as_python()) == 3
 
-    return
-
 
 def test_spend_p2_singleton() -> None:
     # Curried values
@@ -721,7 +723,7 @@ def test_merge_p2_singleton() -> None:
     ]
     amounts = [uint64(1000), uint64(2000), uint64(3000)]
     parent_puzhash_amounts = []
-    merge_coin_ids: List[bytes32] = []
+    merge_coin_ids: list[bytes32] = []
     for pid, amt in zip(parent_ids, amounts):
         parent_puzhash_amounts.append([pid, my_puzhash, amt])
         merge_coin_ids.append(Coin(pid, my_puzhash, amt).name())
@@ -747,8 +749,6 @@ def test_merge_p2_singleton() -> None:
         assert cca in agg_acas
         assert merge_conds[ConditionOpcode.ASSERT_MY_COIN_ID][0].vars[0] == coin_id
 
-    return
-
 
 def test_treasury() -> None:
     """
@@ -820,12 +820,16 @@ def test_treasury() -> None:
 
     # Setup the spend_p2_singleton (proposal inner puz)
     spend_p2_singleton = SPEND_P2_SINGLETON_MOD.curry(
-        treasury_struct, CAT_MOD_HASH, conditions, [], p2_singleton_puzhash  # tailhash conds
+        treasury_struct,
+        CAT_MOD_HASH,
+        conditions,
+        [],
+        p2_singleton_puzhash,  # tailhash conds
     )
     spend_p2_singleton_puzhash = spend_p2_singleton.get_tree_hash()
 
     parent_amt_list = [[parent_id, locked_amount]]
-    cat_parent_amt_list: List[Optional[Any]] = []
+    cat_parent_amt_list: list[Optional[Any]] = []
     spend_p2_singleton_solution = Program.to([parent_amt_list, cat_parent_amt_list, treasury_inner.get_tree_hash()])
 
     proposal: Program = proposal_curry_one.curry(
@@ -1067,12 +1071,16 @@ def test_proposal_lifecycle() -> None:
 
     # Setup the spend_p2_singleton (proposal inner puz)
     spend_p2_singleton = SPEND_P2_SINGLETON_MOD.curry(
-        treasury_singleton_struct, CAT_MOD_HASH, conditions, [], p2_singleton_puzhash  # tailhash conds
+        treasury_singleton_struct,
+        CAT_MOD_HASH,
+        conditions,
+        [],
+        p2_singleton_puzhash,  # tailhash conds
     )
     spend_p2_singleton_puzhash = spend_p2_singleton.get_tree_hash()
 
     parent_amt_list = [[parent_id, locked_amount]]
-    cat_parent_amt_list: List[Optional[Any]] = []
+    cat_parent_amt_list: list[Optional[Any]] = []
     spend_p2_singleton_solution = Program.to([parent_amt_list, cat_parent_amt_list, treasury_inner_puzhash])
 
     # Setup Proposal
@@ -1242,10 +1250,10 @@ def test_proposal_lifecycle() -> None:
 async def do_spend(
     sim: SpendSim,
     sim_client: SimClient,
-    coins: List[Coin],
-    puzzles: List[Program],
-    solutions: List[Program],
-) -> Tuple[MempoolInclusionStatus, Optional[Err]]:
+    coins: list[Coin],
+    puzzles: list[Program],
+    solutions: list[Program],
+) -> tuple[MempoolInclusionStatus, Optional[Err]]:
     spends = []
     for coin, puzzle, solution in zip(coins, puzzles, solutions):
         spends.append(make_spend(coin, puzzle, solution))