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

chia/_tests/check_sql_statements.py

@@ -3,12 +3,11 @@ from __future__ import annotations
 
 import sys
 from subprocess import check_output
-from typing import Dict, Set, Tuple
 
 # check for duplicate index names
 
 
-def check_create(sql_type: str, cwd: str, exemptions: Set[Tuple[str, str]] = set()) -> int:
+def check_create(sql_type: str, cwd: str, exemptions: set[tuple[str, str]] = set()) -> int:
     # the need for this change seems to come from the git precommit plus the python pre-commit environment
     # having GIT_DIR specified but not GIT_WORK_TREE.  this is an issue in some less common git setups
     # such as with worktrees, at least in particular uses of them.  i think that we could switch to letting
@@ -19,7 +18,7 @@ def check_create(sql_type: str, cwd: str, exemptions: Set[Tuple[str, str]] = set
 
     ret = 0
 
-    items: Dict[str, str] = {}
+    items: dict[str, str] = {}
     for line in lines:
         if f"CREATE {sql_type}" not in line:
             continue

chia/_tests/clvm/benchmark_costs.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bundle_tools import simple_solution_generator
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
 from chia.types.blockchain_format.program import INFINITE_COST
 from chia.types.generator_types import BlockGenerator
 from chia.types.spend_bundle import SpendBundle

chia/_tests/clvm/coin_store.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from collections.abc import Iterator
 from dataclasses import dataclass, replace
-from typing import Dict, Iterator, Optional
+from typing import Optional
 
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia.consensus.constants import ConsensusConstants
 from chia.consensus.cost_calculator import NPCResult
 from chia.full_node.bundle_tools import simple_solution_generator
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions, mempool_check_time_locks
+from chia.full_node.mempool_check_conditions import mempool_check_time_locks
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_record import CoinRecord
@@ -30,8 +32,8 @@ class CoinTimestamp:
 
 class CoinStore:
     def __init__(self, constants: ConsensusConstants, reward_mask: int = 0):
-        self._db: Dict[bytes32, CoinRecord] = dict()
-        self._ph_index: Dict = defaultdict(list)
+        self._db: dict[bytes32, CoinRecord] = dict()
+        self._ph_index: dict = defaultdict(list)
         self._reward_mask = reward_mask
         self._constants = constants
 
@@ -40,7 +42,7 @@ class CoinStore:
         puzzle_hash: bytes32,
         birthday: CoinTimestamp,
         amount: int = 1024,
-        prefix=bytes32.fromhex("ccd5bb71183532bff220ba46c268991a00000000000000000000000000000000"),  # noqa
+        prefix=bytes32.fromhex("ccd5bb71183532bff220ba46c268991a00000000000000000000000000000000"),
     ) -> Coin:
         parent = bytes32(
             [

chia/_tests/clvm/test_chialisp_deserialization.py

@@ -64,8 +64,8 @@ def test_deserialization_simple_list():
 def test_deserialization_password_coin():
     # (i (= (sha256 2) (q 0x2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824)) (c (q 51) (c 5 (c (q 100) (q ())))) (q "wrong password"))  # noqa
     b = hexstr_to_bytes(
-        "ff04ffff0affff0bff0280ffff01ffa02cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b98248080ffff05ffff01ff3380ffff05ff05ffff05ffff01ff6480ffff01ff8080808080ffff01ff8e77726f6e672070617373776f72648080"  # noqa
-    )  # noqa
+        "ff04ffff0affff0bff0280ffff01ffa02cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b98248080ffff05ffff01ff3380ffff05ff05ffff05ffff01ff6480ffff01ff8080808080ffff01ff8e77726f6e672070617373776f72648080"
+    )
     cost, output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
     print(cost, output)
     prog = Program.to(output)
@@ -75,8 +75,8 @@ def test_deserialization_password_coin():
 def test_deserialization_large_numbers():
     # '(99999999999999999999999999999999999999999999999999999999999999999 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -99999999999999999999999999999999999999999999999999999999999999999999999999999)'  # noqa
     b = hexstr_to_bytes(
-        "ff9c00f316271c7fc3908a8bef464e3945ef7a253609ffffffffffffffffffb00fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa1ff22ea0179500526edb610f148ec0c614155678491902d6000000000000000000180"  # noqa
-    )  # noqa
+        "ff9c00f316271c7fc3908a8bef464e3945ef7a253609ffffffffffffffffffb00fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa1ff22ea0179500526edb610f148ec0c614155678491902d6000000000000000000180"
+    )
     cost, output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
     print(cost, output)
     prog = Program.to(output)
@@ -86,16 +86,16 @@ def test_deserialization_large_numbers():
 def test_overflow_atoms():
     b = hexstr_to_bytes(serialized_atom_overflow(0xFFFFFFFF))
     with pytest.raises(Exception):
-        cost, output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
+        _cost, _output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
 
     b = hexstr_to_bytes(serialized_atom_overflow(0x3FFFFFFFF))
     with pytest.raises(Exception):
-        cost, output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
+        _cost, _output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
 
     b = hexstr_to_bytes(serialized_atom_overflow(0xFFFFFFFFFF))
     with pytest.raises(Exception):
-        cost, output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
+        _cost, _output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
 
     b = hexstr_to_bytes(serialized_atom_overflow(0x1FFFFFFFFFF))
     with pytest.raises(Exception):
-        cost, output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
+        _cost, _output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])

chia/_tests/clvm/test_condition_codes.py

@@ -9,5 +9,5 @@ from chia.types.condition_opcodes import ConditionOpcode
 def test_condition_codes_is_complete() -> None:
     condition_codes_path = importlib_resources.files("chia.wallet.puzzles").joinpath("condition_codes.clib")
     contents = condition_codes_path.read_text(encoding="utf-8")
-    for name, value in ConditionOpcode.__members__.items():
-        assert f"(defconstant {name} {int_from_bytes(value)})" in contents
+    for opcode in ConditionOpcode:
+        assert f"(defconstant {opcode.name} {int_from_bytes(opcode.value)})" in contents

chia/_tests/clvm/test_curry_and_treehash.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List
-
 import pytest
 
 from chia.types.blockchain_format.program import Program
@@ -35,9 +33,9 @@ def test_curry_and_treehash() -> None:
 
 
 @pytest.mark.parametrize(
-    "value", [[], [bytes32([3] * 32)], [bytes32([0] * 32), bytes32([1] * 32)], [bytes([1]), bytes([1, 2, 3])]]
+    "value", [[], [bytes32([3] * 32)], [bytes32.zeros, bytes32([1] * 32)], [bytes([1]), bytes([1, 2, 3])]]
 )
-def test_shatree_atom_list(value: List[bytes]) -> None:
+def test_shatree_atom_list(value: list[bytes]) -> None:
     h1 = shatree_atom_list(value)
     h2 = Program.to(value).get_tree_hash()
     assert h1 == h2

chia/_tests/clvm/test_message_conditions.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import dataclasses
+
+import pytest
+from chia_rs import Coin, G2Element
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint64
+
+from chia._tests.util.spend_sim import CostLogger, sim_and_client
+from chia.types.blockchain_format.program import Program
+from chia.types.coin_spend import make_spend
+from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.util.errors import Err
+from chia.wallet.conditions import MessageParticipant, ReceiveMessage, SendMessage
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+ACS = Program.to(1)
+ACS_PH = ACS.get_tree_hash()
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "mode",
+    [i for i in range(0b001001, 0b111111 + 1) if i % 8 != 0],  # skipping anything ending in 000
+)
+async def test_basic_message_send_receive(mode: int, cost_logger: CostLogger) -> None:
+    async with sim_and_client() as (sim, client):
+        # Farm two ACS coins
+        await sim.farm_block(ACS_PH)
+        [sender_coin, receiver_coin] = await client.get_coin_records_by_puzzle_hash(ACS_PH)
+
+        # Try only a sent message
+        send_condition = SendMessage(
+            b"foo",
+            mode_integer=uint8(mode),
+            receiver=MessageParticipant(
+                parent_id_committed=receiver_coin.coin.parent_coin_info if mode & 0b000100 else None,
+                puzzle_hash_committed=receiver_coin.coin.puzzle_hash if mode & 0b000010 else None,
+                amount_committed=receiver_coin.coin.amount if mode & 0b000001 else None,
+                coin_id_committed=receiver_coin.coin.name() if mode & 0b000111 == 0b000111 else None,
+            ),
+        )
+        only_sender = WalletSpendBundle(
+            [
+                make_spend(
+                    sender_coin.coin,
+                    ACS,
+                    Program.to([send_condition.to_program()]),
+                ),
+            ],
+            G2Element(),
+        )
+        result = await client.push_tx(only_sender)
+        assert result == (MempoolInclusionStatus.FAILED, Err.MESSAGE_NOT_SENT_OR_RECEIVED)
+
+        # Try only a received message
+        receive_condition = ReceiveMessage(
+            b"foo",
+            mode_integer=uint8(mode),
+            sender=MessageParticipant(
+                parent_id_committed=sender_coin.coin.parent_coin_info if mode & 0b100000 else None,
+                puzzle_hash_committed=sender_coin.coin.puzzle_hash if mode & 0b010000 else None,
+                amount_committed=sender_coin.coin.amount if mode & 0b001000 else None,
+                coin_id_committed=sender_coin.coin.name() if mode & 0b111000 == 0b111000 else None,
+            ),
+        )
+        only_receiver = WalletSpendBundle(
+            [
+                make_spend(
+                    receiver_coin.coin,
+                    ACS,
+                    Program.to([receive_condition.to_program()]),
+                ),
+            ],
+            G2Element(),
+        )
+        result = await client.push_tx(only_receiver)
+        assert result == (MempoolInclusionStatus.FAILED, Err.MESSAGE_NOT_SENT_OR_RECEIVED)
+
+        # Make sure they succeed together
+        result = await client.push_tx(WalletSpendBundle.aggregate([only_sender, only_receiver]))
+        assert result == (MempoolInclusionStatus.SUCCESS, None)
+
+        # Quickly test back and forth parsing
+        assert SendMessage.from_program(send_condition.to_program()).to_program() == send_condition.to_program()
+        assert (
+            ReceiveMessage.from_program(receive_condition.to_program()).to_program() == receive_condition.to_program()
+        )
+
+        # Quickly test mode calculation
+        assert (
+            dataclasses.replace(send_condition, sender=receive_condition.sender, mode_integer=None).mode
+            == send_condition.mode
+        )
+        assert (
+            dataclasses.replace(receive_condition, receiver=send_condition.receiver, mode_integer=None).mode
+            == receive_condition.mode
+        )
+
+
+def test_message_error_conditions() -> None:
+    with pytest.raises(ValueError, match="Must specify at least one committment"):
+        MessageParticipant()
+
+    test_coin = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
+    with pytest.raises(ValueError, match="You must specify all or none"):
+        MessageParticipant(coin_id_committed=test_coin.name(), parent_id_committed=bytes32.zeros)
+
+    with pytest.raises(AssertionError, match="The value for coin_id_committed must be equal"):
+        MessageParticipant(
+            coin_id_committed=test_coin.name(),
+            parent_id_committed=bytes32.zeros,
+            puzzle_hash_committed=bytes32.zeros,
+            amount_committed=uint64(1),
+        )
+
+    for mode in range(0b001, 0b111 + 1):
+        with pytest.raises(AssertionError, match="If mode_integer is manually specified"):
+            MessageParticipant(
+                mode_integer=uint8(mode),
+                parent_id_committed=test_coin.parent_coin_info if not mode & 0b100 else None,
+                puzzle_hash_committed=test_coin.puzzle_hash if not mode & 0b010 else None,
+                amount_committed=test_coin.amount if (not mode & 0b001) or (mode == 0b111) else None,
+            )
+
+    with pytest.raises(ValueError, match="without committment information"):
+        MessageParticipant(
+            mode_integer=uint8(0b111),
+        ).necessary_args
+
+    with pytest.raises(ValueError, match="Must specify either mode_integer or both sender and reciever"):
+        SendMessage(
+            msg=b"foo",
+            sender=MessageParticipant(coin_id_committed=test_coin.name()),
+        )
+
+    with pytest.raises(ValueError, match="Must specify either mode_integer or both sender and reciever"):
+        SendMessage(
+            msg=b"foo",
+            receiver=MessageParticipant(coin_id_committed=test_coin.name()),
+        )
+
+    with pytest.raises(AssertionError, match="don't match the sender's mode"):
+        SendMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+            sender=MessageParticipant(mode_integer=uint8(0b001)),
+        )
+
+    with pytest.raises(AssertionError, match="don't match the receiver's mode"):
+        SendMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+            receiver=MessageParticipant(mode_integer=uint8(0b001)),
+        )
+
+    with pytest.raises(ValueError, match="Must specify either var_args or receiver"):
+        SendMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+        )
+
+    with pytest.raises(ValueError, match="Must specify either var_args or sender"):
+        ReceiveMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+        )
+
+    with pytest.raises(AssertionError, match="do not match the specified arguments"):
+        SendMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+            var_args=[Program.to(test_coin.name())],
+            receiver=MessageParticipant(coin_id_committed=bytes32.zeros),
+        )
+
+    with pytest.raises(AssertionError, match="do not match the specified arguments"):
+        ReceiveMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+            var_args=[Program.to(test_coin.name())],
+            sender=MessageParticipant(coin_id_committed=bytes32.zeros),
+        )

chia/_tests/clvm/test_puzzle_compression.py

@@ -24,9 +24,8 @@ from chia.wallet.util.puzzle_compression import (
     lowest_best_version,
 )
 
-ZERO_32 = bytes32([0] * 32)
 ONE_32 = bytes32([17] * 32)
-COIN = Coin(ZERO_32, ZERO_32, uint64(0))
+COIN = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
 SOLUTION = Program.to([])
 
 

chia/_tests/clvm/test_puzzle_drivers.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import pytest
 
@@ -9,7 +9,7 @@ from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
 
 
 def test_puzzle_info() -> None:
-    test_driver: Dict[str, Any] = {
+    test_driver: dict[str, Any] = {
         "string": "hello",
         "bytes": "0xcafef00d",
         "int": "123",
@@ -17,7 +17,7 @@ def test_puzzle_info() -> None:
         "zero": "0",
         "nil": "()",
     }
-    test_also: Dict[str, Any] = {"type": "TEST", "string": "hello"}
+    test_also: dict[str, Any] = {"type": "TEST", "string": "hello"}
     test_driver["also"] = test_also
 
     with pytest.raises(ValueError, match="A type is required"):

chia/_tests/clvm/test_puzzles.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
-from typing import Iterable, List, Tuple
+from collections.abc import Iterable
 
-from chia_rs import AugSchemeMPL, G1Element, G2Element
+from chia_rs import AugSchemeMPL, G1Element
 
+from chia._tests.clvm.coin_store import CoinStore, CoinTimestamp
+from chia._tests.core.make_block_generator import int_to_public_key
 from chia._tests.util.key_tool import KeyTool
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.program import Program
@@ -22,13 +24,10 @@ from chia.wallet.puzzles import (
 )
 from chia.wallet.puzzles.puzzle_utils import make_create_coin_condition
 
-from ..core.make_block_generator import int_to_public_key
-from .coin_store import CoinStore, CoinTimestamp
-
 T1 = CoinTimestamp(1, uint32(10000000))
 T2 = CoinTimestamp(5, uint32(10003000))
 
-MAX_BLOCK_COST_CLVM = int(1e18)
+MAX_BLOCK_COST_CLVM = 10**18
 
 
 def secret_exponent_for_index(index: int) -> int:
@@ -51,7 +50,7 @@ def throwaway_puzzle_hash(index: int, key_lookup: KeyTool) -> bytes32:
 def do_test_spend(
     puzzle_reveal: Program,
     solution: Program,
-    payments: Iterable[Tuple[bytes32, int]],
+    payments: Iterable[tuple[bytes32, int]],
     key_lookup: KeyTool,
     farm_time: CoinTimestamp = T1,
     spend_time: CoinTimestamp = T2,
@@ -60,8 +59,7 @@ def do_test_spend(
     This method will farm a coin paid to the hash of `puzzle_reveal`, then try to spend it
     with `solution`, and verify that the created coins correspond to `payments`.
 
-    The `key_lookup` is used to create a signed version of the `SpendBundle`, although at
-    this time, signatures are not verified.
+    The `key_lookup` is used to create a signed version of the `SpendBundle`
     """
 
     coin_db = CoinStore(DEFAULT_CONSTANTS)
@@ -74,7 +72,9 @@ def do_test_spend(
     # spend it
     coin_spend = make_spend(coin, puzzle_reveal, solution)
 
-    spend_bundle = SpendBundle([coin_spend], G2Element())
+    # sign the solution
+    signature = key_lookup.signature_for_solution(coin_spend, DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA)
+    spend_bundle = SpendBundle([coin_spend], signature)
     coin_db.update_coin_store_for_spend_bundle(spend_bundle, spend_time, MAX_BLOCK_COST_CLVM)
 
     # ensure all outputs are there
@@ -85,17 +85,12 @@ def do_test_spend(
         else:
             assert 0
 
-    # make sure we can actually sign the solution
-    signatures: List[G2Element] = []
-    for coin_spend in spend_bundle.coin_spends:
-        signature = key_lookup.signature_for_solution(coin_spend, bytes([2] * 32))
-        signatures.append(signature)
-    return SpendBundle(spend_bundle.coin_spends, AugSchemeMPL.aggregate(signatures))
+    return spend_bundle
 
 
 def default_payments_and_conditions(
     initial_index: int, key_lookup: KeyTool
-) -> Tuple[List[Tuple[bytes32, int]], Program]:
+) -> tuple[list[tuple[bytes32, int]], Program]:
     # the coin we get from coin_db.farm_coin only has amount 1024, so we can
     # only make small payments to avoid failing with MINTING_COIN
     payments = [
@@ -206,7 +201,7 @@ def test_p2_delegated_puzzle_or_hidden_puzzle_with_hidden_puzzle():
 
 def do_test_spend_p2_delegated_puzzle_or_hidden_puzzle_with_delegated_puzzle(hidden_pub_key_index):
     key_lookup = KeyTool()
-    payments, conditions = default_payments_and_conditions(1, key_lookup)
+    _payments, conditions = default_payments_and_conditions(1, key_lookup)
 
     hidden_puzzle = p2_conditions.puzzle_for_conditions(conditions)
     hidden_public_key = public_key_for_index(hidden_pub_key_index, key_lookup)

chia/_tests/clvm/test_singletons.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-from typing import List, Optional, Tuple
+from typing import Optional
 
 import pytest
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
 
 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.clvm.spend_sim import CostLogger, SimClient, SpendSim, sim_and_client
+from chia._tests.util.spend_sim import CostLogger, SimClient, SpendSim, sim_and_client
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -36,7 +36,7 @@ class TransactionPushError(Exception):
 
 
 def sign_delegated_puz(del_puz: Program, coin: Coin) -> G2Element:
-    synthetic_secret_key: PrivateKey = p2_delegated_puzzle_or_hidden_puzzle.calculate_synthetic_secret_key(  # noqa
+    synthetic_secret_key: PrivateKey = p2_delegated_puzzle_or_hidden_puzzle.calculate_synthetic_secret_key(
         PrivateKey.from_bytes(
             secret_exponent_for_index(1).to_bytes(32, "big"),
         ),
@@ -44,7 +44,7 @@ def sign_delegated_puz(del_puz: Program, coin: Coin) -> G2Element:
     )
     return AugSchemeMPL.sign(
         synthetic_secret_key,
-        (del_puz.get_tree_hash() + coin.name() + DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA),  # noqa
+        (del_puz.get_tree_hash() + coin.name() + DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA),
     )
 
 
@@ -54,7 +54,7 @@ async def make_and_spend_bundle(
     sim_client: SimClient,
     coin: Coin,
     delegated_puzzle: Program,
-    coinsols: List[CoinSpend],
+    coinsols: list[CoinSpend],
     ex_error: Optional[Err] = None,
     fail_msg: str = "",
     cost_logger: Optional[CostLogger] = None,
@@ -69,7 +69,7 @@ async def make_and_spend_bundle(
         spend_bundle = cost_logger.add_cost(cost_log_msg, spend_bundle)
 
     try:
-        result, error = await sim_client.push_tx(spend_bundle)
+        _result, error = await sim_client.push_tx(spend_bundle)
         if error is None:
             await sim.farm_block()
         elif ex_error is not None:
@@ -88,12 +88,12 @@ async def test_singleton_top_layer(version, cost_logger):
         # Generate starting info
         key_lookup = KeyTool()
         pk: G1Element = G1Element.from_bytes(public_key_for_index(1, key_lookup))
-        starting_puzzle: Program = p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_pk(pk)  # noqa
+        starting_puzzle: Program = p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_pk(pk)
 
         if version == 0:
             from chia.wallet.puzzles import singleton_top_layer
 
-            adapted_puzzle: Program = singleton_top_layer.adapt_inner_to_singleton(starting_puzzle)  # noqa
+            adapted_puzzle: Program = singleton_top_layer.adapt_inner_to_singleton(starting_puzzle)
         else:
             from chia.wallet.puzzles import singleton_top_layer_v1_1 as singleton_top_layer
 
@@ -105,24 +105,24 @@ async def test_singleton_top_layer(version, cost_logger):
         await sim.farm_block(starting_puzzle.get_tree_hash())
         starting_coin: Coin = await sim_client.get_coin_records_by_puzzle_hash(starting_puzzle.get_tree_hash())
         starting_coin = starting_coin[0].coin
-        comment: List[Tuple[str, str]] = [("hello", "world")]
+        comment: list[tuple[str, str]] = [("hello", "world")]
 
         # LAUNCHING
         # Try to create an even singleton (driver test)
         try:
-            conditions, launcher_coinsol = singleton_top_layer.launch_conditions_and_coinsol(  # noqa
+            conditions, launcher_coinsol = singleton_top_layer.launch_conditions_and_coinsol(
                 starting_coin, adapted_puzzle, comment, (START_AMOUNT - 1)
             )
             raise AssertionError("This should fail due to an even amount")
         except ValueError as msg:
             assert str(msg) == "Coin amount cannot be even. Subtract one mojo."
-            conditions, launcher_coinsol = singleton_top_layer.launch_conditions_and_coinsol(  # noqa
+            conditions, launcher_coinsol = singleton_top_layer.launch_conditions_and_coinsol(
                 starting_coin, adapted_puzzle, comment, START_AMOUNT
             )
 
         # Creating solution for standard transaction
-        delegated_puzzle: Program = p2_conditions.puzzle_for_conditions(conditions)  # noqa
-        full_solution: Program = p2_delegated_puzzle_or_hidden_puzzle.solution_for_conditions(conditions)  # noqa
+        delegated_puzzle: Program = p2_conditions.puzzle_for_conditions(conditions)
+        full_solution: Program = p2_delegated_puzzle_or_hidden_puzzle.solution_for_conditions(conditions)
 
         starting_coinsol = make_spend(
             starting_coin,
@@ -162,7 +162,7 @@ async def test_singleton_top_layer(version, cost_logger):
         )
         inner_solution: Program = Program.to([[], delegated_puzzle, []])
         # Generate the lineage proof we will need from the launcher coin
-        lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(launcher_coinsol)  # noqa
+        lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(launcher_coinsol)
         puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
             launcher_id,
             adapted_puzzle,
@@ -192,7 +192,7 @@ async def test_singleton_top_layer(version, cost_logger):
         # POST-EVE
         singleton: Coin = (await sim.all_non_reward_coins())[0]
         # Same delegated_puzzle / inner_solution. We're just recreating ourself
-        lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(singleton_eve_coinsol)  # noqa
+        lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(singleton_eve_coinsol)
         # Same puzzle_reveal too
         full_solution: Program = singleton_top_layer.solution_for_singleton(
             lineage_proof,
@@ -334,7 +334,7 @@ async def test_singleton_top_layer(version, cost_logger):
             DELAY_TIME,
             DELAY_PH,
         )
-        result, error = await sim_client.push_tx(SpendBundle([to_delay_ph_coinsol], G2Element()))
+        _result, error = await sim_client.push_tx(SpendBundle([to_delay_ph_coinsol], G2Element()))
         assert error == Err.ASSERT_SECONDS_RELATIVE_FAILED
 
         # SPEND TO DELAYED PUZZLE HASH
@@ -471,7 +471,7 @@ async def test_singleton_top_layer(version, cost_logger):
             )
         )
         inner_solution: Program = Program.to([[], delegated_puzzle, []])
-        lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(singleton_even_coinsol)  # noqa
+        lineage_proof: LineageProof = singleton_top_layer.lineage_proof_for_coinsol(singleton_even_coinsol)
         puzzle_reveal: Program = singleton_top_layer.puzzle_for_singleton(
             launcher_id,
             adapted_puzzle,

chia/_tests/clvm/test_spend_sim.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import pytest
 from chia_rs import G2Element
 
-from chia.clvm.spend_sim import sim_and_client
+from chia._tests.util.spend_sim import sim_and_client
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_spend import compute_additions, make_spend
@@ -41,7 +41,7 @@ async def test_all_endpoints():
     async with sim_and_client() as (sim, sim_client):
         for i in range(0, 5):
             await sim.farm_block()
-        await sim.farm_block(bytes32([0] * 32))
+        await sim.farm_block(bytes32.zeros)
         await sim.farm_block(bytes32([1] * 32))
         for i in range(0, 5):
             await sim.farm_block()
@@ -95,19 +95,19 @@ async def test_all_endpoints():
         assert len(coin_records) == 0
 
         # get_coin_records_by_puzzle_hash
-        coin_records = await sim_client.get_coin_records_by_puzzle_hash(bytes32([0] * 32))
+        coin_records = await sim_client.get_coin_records_by_puzzle_hash(bytes32.zeros)
         coin_record_name = coin_records[0].coin.name()
         assert len(coin_records) == 2
 
-        coin_records = await sim_client.get_coin_records_by_puzzle_hash(bytes32([0] * 32), start_height=0, end_height=2)
+        coin_records = await sim_client.get_coin_records_by_puzzle_hash(bytes32.zeros, start_height=0, end_height=2)
         assert len(coin_records) == 0
 
         # get_coin_records_by_puzzle_hashes
-        coin_records = await sim_client.get_coin_records_by_puzzle_hashes([bytes32([0] * 32), bytes32([1] * 32)])
+        coin_records = await sim_client.get_coin_records_by_puzzle_hashes([bytes32.zeros, bytes32([1] * 32)])
         assert len(coin_records) == 4
 
         coin_records = await sim_client.get_coin_records_by_puzzle_hashes(
-            [bytes32([0] * 32), bytes32([1] * 32)], start_height=0, end_height=2
+            [bytes32.zeros, bytes32([1] * 32)], start_height=0, end_height=2
         )
         assert len(coin_records) == 0
 
@@ -150,7 +150,7 @@ async def test_all_endpoints():
             ],
             G2Element(),
         )
-        result, error = await sim_client.push_tx(bundle)
+        _result, error = await sim_client.push_tx(bundle)
         assert not error
         # get_all_mempool_tx_ids
         mempool_items = await sim_client.get_all_mempool_tx_ids()