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

chia/_tests/wallet/test_wallet_node.py

@@ -5,25 +5,26 @@ import sys
 import time
 import types
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 import pytest
 from chia_rs import G1Element, PrivateKey
 
-from chia._tests.util.misc import CoinGenerator, add_blocks_in_batches
+from chia._tests.util.misc import CoinGenerator, patch_request_handler
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.protocols import wallet_protocol
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.wallet_protocol import CoinState
+from chia.server.api_protocol import Self
 from chia.server.outbound_message import Message, make_msg
+from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.simulator.block_tools import test_constants
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.full_block import FullBlock
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.peer_info import PeerInfo
-from chia.util.api_decorators import Self, api_request
 from chia.util.config import load_config
 from chia.util.errors import Err
 from chia.util.ints import uint8, uint32, uint64, uint128
@@ -112,7 +113,7 @@ async def test_get_private_key_missing_key_use_default(
 async def test_get_public_key(root_path_populated_with_config: Path, get_temp_keyring: Keychain) -> None:
     root_path: Path = root_path_populated_with_config
     keychain: Keychain = get_temp_keyring
-    config: Dict[str, Any] = load_config(root_path, "config.yaml", "wallet")
+    config: dict[str, Any] = load_config(root_path, "config.yaml", "wallet")
     node: WalletNode = WalletNode(config, root_path, test_constants, keychain)
     pk: G1Element = keychain.add_key(
         "c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -132,7 +133,7 @@ async def test_get_public_key(root_path_populated_with_config: Path, get_temp_ke
 async def test_get_public_key_default_key(root_path_populated_with_config: Path, get_temp_keyring: Keychain) -> None:
     root_path: Path = root_path_populated_with_config
     keychain: Keychain = get_temp_keyring
-    config: Dict[str, Any] = load_config(root_path, "config.yaml", "wallet")
+    config: dict[str, Any] = load_config(root_path, "config.yaml", "wallet")
     node: WalletNode = WalletNode(config, root_path, test_constants, keychain)
     pk: G1Element = keychain.add_key(
         "c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -168,7 +169,7 @@ async def test_get_public_key_missing_key(
 ) -> None:
     root_path: Path = root_path_populated_with_config
     keychain: Keychain = get_temp_keyring  # empty keyring
-    config: Dict[str, Any] = load_config(root_path, "config.yaml", "wallet")
+    config: dict[str, Any] = load_config(root_path, "config.yaml", "wallet")
     node: WalletNode = WalletNode(config, root_path, test_constants, keychain)
 
     # Keyring is empty, so requesting a key by fingerprint or None should return None
@@ -183,7 +184,7 @@ async def test_get_public_key_missing_key_use_default(
 ) -> None:
     root_path: Path = root_path_populated_with_config
     keychain: Keychain = get_temp_keyring
-    config: Dict[str, Any] = load_config(root_path, "config.yaml", "wallet")
+    config: dict[str, Any] = load_config(root_path, "config.yaml", "wallet")
     node: WalletNode = WalletNode(config, root_path, test_constants, keychain)
     pk: G1Element = keychain.add_key(
         "c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
@@ -299,7 +300,7 @@ def test_get_last_used_fingerprint_file_doesnt_exist(root_path_populated_with_co
 
 
 def test_get_last_used_fingerprint_file_cant_read_unix(root_path_populated_with_config: Path) -> None:
-    if sys.platform in ["win32", "cygwin"]:
+    if sys.platform in {"win32", "cygwin"}:
         pytest.skip("Setting UNIX file permissions doesn't apply to Windows")
 
     root_path = root_path_populated_with_config
@@ -331,7 +332,7 @@ def test_get_last_used_fingerprint_file_cant_read_unix(root_path_populated_with_
 def test_get_last_used_fingerprint_file_cant_read_win32(
     root_path_populated_with_config: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    if sys.platform not in ["win32", "cygwin"]:
+    if sys.platform not in {"win32", "cygwin"}:
         pytest.skip("Windows-specific test")
 
     called_read_text = False
@@ -439,7 +440,7 @@ async def test_get_timestamp_for_height_from_peer(
     await wallet_server.start_client(PeerInfo(self_hostname, full_node_api.server.get_port()), None)
     wallet = wallet_node.wallet_state_manager.main_wallet
     await full_node_api.farm_blocks_to_wallet(2, wallet)
-    full_node_peer = list(wallet_server.all_connections.values())[0]
+    full_node_peer = next(iter(wallet_server.all_connections.values()))
     # There should be no timestamp available for height 10
     assert await get_timestamp(10) is None
     # The timestamp at peak height should match the one from the full node block_store.
@@ -493,9 +494,9 @@ async def test_unique_puzzle_hash_subscriptions(simulator_and_wallet: OldSimulat
 @pytest.mark.anyio
 @pytest.mark.standard_block_tools
 async def test_get_balance(
-    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str, default_400_blocks: List[FullBlock]
+    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str, default_400_blocks: list[FullBlock]
 ) -> None:
-    [full_node_api], [(wallet_node, wallet_server)], bt = simulator_and_wallet
+    [full_node_api], [(wallet_node, wallet_server)], _bt = simulator_and_wallet
     full_node_server = full_node_api.full_node.server
 
     def wallet_synced() -> bool:
@@ -578,7 +579,7 @@ async def test_add_states_from_peer_reorg_failure(
     coin_generator = CoinGenerator()
     coin_states = [CoinState(coin_generator.get().coin, None, None)]
     with caplog.at_level(logging.DEBUG):
-        full_node_peer = list(wallet_server.all_connections.values())[0]
+        full_node_peer = next(iter(wallet_server.all_connections.values()))
         # Close the connection to trigger a state processing failure during reorged coin processing.
         await full_node_peer.close()
         assert not await wallet_node.add_states_from_peer(coin_states, full_node_peer)
@@ -599,7 +600,9 @@ async def test_add_states_from_peer_untrusted_shutdown(
     # Generate enough coin states to fill up the max number validation/add tasks.
     coin_states = [CoinState(coin_generator.get().coin, uint32(i), uint32(i)) for i in range(3000)]
     with caplog.at_level(logging.INFO):
-        assert not await wallet_node.add_states_from_peer(coin_states, list(wallet_server.all_connections.values())[0])
+        assert not await wallet_node.add_states_from_peer(
+            coin_states, next(iter(wallet_server.all_connections.values()))
+        )
         assert "Terminating receipt and validation due to shut down request" in caplog.text
 
 
@@ -622,7 +625,6 @@ async def test_transaction_send_cache(
     # Replacing the normal logic a full node has for processing transactions with a function that just logs what it gets
     logged_spends = []
 
-    @api_request()
     async def send_transaction(
         self: Self, request: wallet_protocol.SendTransaction, *, test: bool = False
     ) -> Optional[Message]:
@@ -630,48 +632,46 @@ async def test_transaction_send_cache(
         return None
 
     assert full_node_api.full_node._server is not None
-    monkeypatch.setattr(
-        full_node_api.full_node._server.get_connections()[0].api,
-        "send_transaction",
-        types.MethodType(send_transaction, full_node_api.full_node._server.get_connections()[0].api),
-    )
-
-    # Generate the transaction
-    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        await wallet.generate_signed_transaction(uint64(0), bytes32([0] * 32), action_scope)
-    [tx] = action_scope.side_effects.transactions
-
-    # Make sure it is sent to the peer
-    await wallet_node._resend_queue()
+    with patch_request_handler(api=full_node_api.full_node._server.get_connections()[0].api, handler=send_transaction):
+        # Generate the transaction
+        async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            await wallet.generate_signed_transaction(uint64(0), bytes32.zeros, action_scope)
+        [tx] = action_scope.side_effects.transactions
+
+        # Make sure it is sent to the peer
+        await wallet_node._resend_queue()
+
+        def logged_spends_len() -> int:
+            return len(logged_spends)
+
+        await time_out_assert(5, logged_spends_len, 1)
+
+        # Make sure queue processing again does not result in another spend
+        await wallet_node._resend_queue()
+        with pytest.raises(AssertionError):
+            await time_out_assert(5, logged_spends_len, 2)
+
+        # Tell the wallet that we recieved the spend (but failed to process it so it should send again)
+        msg = make_msg(
+            ProtocolMessageTypes.transaction_ack,
+            wallet_protocol.TransactionAck(
+                tx.name, uint8(MempoolInclusionStatus.FAILED), Err.GENERATOR_RUNTIME_ERROR.name
+            ),
+        )
+        assert simulator_and_wallet[1][0][0]._server is not None
+        await simulator_and_wallet[1][0][0]._server.get_connections()[0].incoming_queue.put(msg)
 
-    def logged_spends_len() -> int:
-        return len(logged_spends)
+        # Make sure the cache is emptied
+        def check_wallet_cache_empty() -> bool:
+            return wallet_node._tx_messages_in_progress == {}
 
-    await time_out_assert(5, logged_spends_len, 1)
+        await time_out_assert(5, check_wallet_cache_empty, True)
 
-    # Make sure queue processing again does not result in another spend
-    await wallet_node._resend_queue()
-    with pytest.raises(AssertionError):
+        # Re-process the queue again and this time it should result in a resend
+        await wallet_node._resend_queue()
         await time_out_assert(5, logged_spends_len, 2)
+        assert logged_spends == [tx.name, tx.name]
 
-    # Tell the wallet that we recieved the spend (but failed to process it so it should send again)
-    msg = make_msg(
-        ProtocolMessageTypes.transaction_ack,
-        wallet_protocol.TransactionAck(tx.name, uint8(MempoolInclusionStatus.FAILED), Err.GENERATOR_RUNTIME_ERROR.name),
-    )
-    assert simulator_and_wallet[1][0][0]._server is not None
-    await simulator_and_wallet[1][0][0]._server.get_connections()[0].incoming_queue.put(msg)
-
-    # Make sure the cache is emptied
-    def check_wallet_cache_empty() -> bool:
-        return wallet_node._tx_messages_in_progress == {}
-
-    await time_out_assert(5, check_wallet_cache_empty, True)
-
-    # Re-process the queue again and this time it should result in a resend
-    await wallet_node._resend_queue()
-    await time_out_assert(5, logged_spends_len, 2)
-    assert logged_spends == [tx.name, tx.name]
     await time_out_assert(5, check_wallet_cache_empty, False)
 
     # Disconnect from the peer to make sure their entry in the cache is also deleted
@@ -688,14 +688,13 @@ async def test_wallet_node_bad_coin_state_ignore(
 
     await wallet_server.start_client(PeerInfo(self_hostname, full_node_api.server.get_port()), None)
 
-    @api_request()
-    async def register_interest_in_coin(
+    async def register_for_coin_updates(
         self: Self, request: wallet_protocol.RegisterForCoinUpdates, *, test: bool = False
     ) -> Optional[Message]:
         return make_msg(
-            ProtocolMessageTypes.respond_to_coin_update,
+            ProtocolMessageTypes.respond_to_coin_updates,
             wallet_protocol.RespondToCoinUpdates(
-                [], uint32(0), [CoinState(Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(0)), uint32(0), uint32(0))]
+                [], uint32(0), [CoinState(Coin(bytes32.zeros, bytes32.zeros, uint64(0)), uint32(0), uint32(0))]
             ),
         )
 
@@ -704,27 +703,25 @@ async def test_wallet_node_bad_coin_state_ignore(
         return True  # pragma: no cover
 
     assert full_node_api.full_node._server is not None
-    monkeypatch.setattr(
-        full_node_api.full_node._server.get_connections()[0].api,
-        "register_interest_in_coin",
-        types.MethodType(register_interest_in_coin, full_node_api.full_node._server.get_connections()[0].api),
-    )
-    monkeypatch.setattr(
-        wallet_node,
-        "validate_received_state_from_peer",
-        types.MethodType(validate_received_state_from_peer, wallet_node),
-    )
+    with patch_request_handler(
+        api=full_node_api.full_node._server.get_connections()[0].api, handler=register_for_coin_updates
+    ):
+        monkeypatch.setattr(
+            wallet_node,
+            "validate_received_state_from_peer",
+            types.MethodType(validate_received_state_from_peer, wallet_node),
+        )
 
-    with pytest.raises(PeerRequestException):
-        await wallet_node.get_coin_state([], wallet_node.get_full_node_peer())
+        with pytest.raises(PeerRequestException):
+            await wallet_node.get_coin_state([], wallet_node.get_full_node_peer())
 
 
 @pytest.mark.anyio
 @pytest.mark.standard_block_tools
 async def test_start_with_multiple_key_types(
-    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str, default_400_blocks: List[FullBlock]
+    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str, default_400_blocks: list[FullBlock]
 ) -> None:
-    [full_node_api], [(wallet_node, wallet_server)], bt = simulator_and_wallet
+    [_full_node_api], [(wallet_node, _wallet_server)], _bt = simulator_and_wallet
 
     async def restart_with_fingerprint(fingerprint: Optional[int]) -> None:
         wallet_node._close()
@@ -753,9 +750,9 @@ async def test_start_with_multiple_key_types(
 @pytest.mark.anyio
 @pytest.mark.standard_block_tools
 async def test_start_with_multiple_keys(
-    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str, default_400_blocks: List[FullBlock]
+    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str, default_400_blocks: list[FullBlock]
 ) -> None:
-    [full_node_api], [(wallet_node, wallet_server)], bt = simulator_and_wallet
+    [_full_node_api], [(wallet_node, _wallet_server)], _bt = simulator_and_wallet
 
     async def restart_with_fingerprint(fingerprint: Optional[int]) -> None:
         wallet_node._close()

chia/_tests/wallet/test_wallet_retry.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Any, List, Tuple
+from typing import Any
 
 import pytest
 
@@ -36,11 +36,11 @@ def evict_from_pool(node: FullNodeAPI, sb: WalletSpendBundle) -> None:
 
 @pytest.mark.anyio
 async def test_wallet_tx_retry(
-    setup_two_nodes_and_wallet_fast_retry: Tuple[List[FullNodeSimulator], List[Tuple[Any, Any]], BlockTools],
+    setup_two_nodes_and_wallet_fast_retry: tuple[list[FullNodeSimulator], list[tuple[Any, Any]], BlockTools],
     self_hostname: str,
 ) -> None:
     wait_secs = 20
-    nodes, wallets, bt = setup_two_nodes_and_wallet_fast_retry
+    nodes, wallets, _bt = setup_two_nodes_and_wallet_fast_retry
     server_1 = nodes[0].full_node.server
     full_node_1: FullNodeSimulator = nodes[0]
     wallet_node_1: WalletNode = wallets[0][0]

chia/_tests/wallet/test_wallet_state_manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import AsyncIterator, List
 
 import pytest
 from chia_rs import G2Element
@@ -9,6 +9,7 @@ from chia_rs import G2Element
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
 from chia.protocols.wallet_protocol import CoinState
+from chia.rpc.wallet_request_types import PushTransactions
 from chia.server.outbound_message import NodeType
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -125,20 +126,20 @@ async def test_commit_transactions_to_db(wallet_environments: WalletTestFramewor
         coins = list(await wsm.main_wallet.select_coins(uint64(2_000_000_000_000), action_scope))
         await wsm.main_wallet.generate_signed_transaction(
             uint64(0),
-            bytes32([0] * 32),
+            bytes32.zeros,
             action_scope,
             coins={coins[0]},
         )
         await wsm.main_wallet.generate_signed_transaction(
             uint64(0),
-            bytes32([0] * 32),
+            bytes32.zeros,
             action_scope,
             coins={coins[1]},
         )
 
     created_txs = action_scope.side_effects.transactions
 
-    def flatten_spend_bundles(txs: List[TransactionRecord]) -> List[WalletSpendBundle]:
+    def flatten_spend_bundles(txs: list[TransactionRecord]) -> list[WalletSpendBundle]:
         return [tx.spend_bundle for tx in txs if tx.spend_bundle is not None]
 
     assert (
@@ -224,7 +225,13 @@ async def test_confirming_txs_not_ours(wallet_environments: WalletTestFramework)
             action_scope,
         )
 
-    await env_2.rpc_client.push_transactions(action_scope.side_effects.transactions)
+    await env_2.rpc_client.push_transactions(
+        PushTransactions(
+            transactions=action_scope.side_effects.transactions,
+            sign=False,
+        ),
+        wallet_environments.tx_config,
+    )
 
     await wallet_environments.process_pending_states(
         [

chia/_tests/wallet/test_wallet_trade_store.py

@@ -133,7 +133,7 @@ async def test_valid_times_migration() -> None:
             )
 
         fake_offer = Offer({}, WalletSpendBundle([], G2Element()), {})
-        fake_coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(0))
+        fake_coin = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
         old_record = TradeRecordOld(
             confirmed_at_index=uint32(0),
             accepted_at_time=None,
@@ -143,7 +143,7 @@ async def test_valid_times_migration() -> None:
             offer=bytes(fake_offer),
             taken_offer=None,
             coins_of_interest=[fake_coin],
-            trade_id=bytes32([0] * 32),
+            trade_id=bytes32.zeros,
             status=uint32(TradeStatus.PENDING_ACCEPT.value),
             sent_to=[],
         )

chia/_tests/wallet/test_wallet_utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Collection, Dict, List, Optional, Set, Tuple
+from collections.abc import Collection
+from typing import Optional
 
 import pytest
 from chia_rs import Coin, CoinState
@@ -22,7 +23,7 @@ coin_states = [
 ]
 
 
-def assert_race_cache(cache: PeerRequestCache, expected_entries: Dict[int, Set[CoinState]]) -> None:
+def assert_race_cache(cache: PeerRequestCache, expected_entries: dict[int, set[CoinState]]) -> None:
     for i in range(100):
         if i in expected_entries:
             assert cache.get_race_cache(i) == expected_entries[i], f"failed for {i}"
@@ -39,7 +40,7 @@ def dummy_coin_state(*, created_height: Optional[int], spent_height: Optional[in
     )
 
 
-def heights(coin_states: Collection[CoinState]) -> List[Tuple[Optional[int], Optional[int]]]:
+def heights(coin_states: Collection[CoinState]) -> list[tuple[Optional[int], Optional[int]]]:
     return [(coin_state.created_height, coin_state.spent_height) for coin_state in coin_states]
 
 
@@ -67,7 +68,7 @@ def test_sort_coin_states() -> None:
 
 def test_add_states_to_race_cache() -> None:
     cache = PeerRequestCache()
-    expected_entries: Dict[int, Set[CoinState]] = {}
+    expected_entries: dict[int, set[CoinState]] = {}
     assert_race_cache(cache, expected_entries)
 
     # Repeated adding of the same coin state should not have any impact

chia/_tests/wallet/vc_wallet/test_cr_outer_puzzle.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import Optional
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -20,7 +20,7 @@ from chia.wallet.vc_wallet.cr_cat_drivers import construct_cr_layer
 
 
 def test_cat_outer_puzzle() -> None:
-    authorized_providers: List[bytes32] = [bytes32([0] * 32), bytes32([0] * 32)]
+    authorized_providers: list[bytes32] = [bytes32.zeros, bytes32.zeros]
     proofs_checker: Program = Program.to(None)
     ACS: Program = Program.to(1)
     cr_puzzle: Program = construct_cr_layer(authorized_providers, proofs_checker, ACS)
@@ -42,7 +42,7 @@ def test_cat_outer_puzzle() -> None:
     assert create_asset_id(cr_driver) is None
 
     # Set up for solve
-    coin: Coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(0))
+    coin: Coin = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
     coin_as_hex: str = (
         "0x" + coin.parent_coin_info.hex() + coin.puzzle_hash.hex() + uint64(coin.amount).stream_to_bytes().hex()
     )

chia/_tests/wallet/vc_wallet/test_vc_lifecycle.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 import itertools
-from typing import List, Optional, Tuple
+from typing import Optional
 
 import pytest
 from chia_rs import G2Element
 
-from chia.clvm.spend_sim import CostLogger, sim_and_client
+from chia._tests.util.spend_sim import CostLogger, sim_and_client
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -47,7 +47,7 @@ ACS_PH: bytes32 = ACS.get_tree_hash()
 ACS_2_PH: bytes32 = ACS_2.get_tree_hash()
 MOCK_SINGLETON_MOD: Program = Program.to([2, 5, 11])
 MOCK_SINGLETON_MOD_HASH: bytes32 = MOCK_SINGLETON_MOD.get_tree_hash()
-MOCK_LAUNCHER_ID: bytes32 = bytes32([0] * 32)
+MOCK_LAUNCHER_ID: bytes32 = bytes32.zeros
 MOCK_LAUNCHER_HASH: bytes32 = bytes32([1] * 32)
 MOCK_SINGLETON: Program = MOCK_SINGLETON_MOD.curry(
     (MOCK_SINGLETON_MOD_HASH, (MOCK_LAUNCHER_ID, MOCK_LAUNCHER_HASH)),
@@ -105,7 +105,7 @@ async def test_covenant_layer(cost_logger: CostLogger) -> None:
         ].coin
 
         # With the honest coin, attempt to spend the non-eve case too soon
-        result: Tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
+        result: tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
             WalletSpendBundle(
                 [
                     make_spend(
@@ -193,7 +193,7 @@ async def test_did_tp(cost_logger: CostLogger) -> None:
         # (mod (METADATA TP solution) (a (q . (c (c (q . 1) (c 2 (c 5 ()))) 11)) (a TP (list METADATA () solution))))
         # (a (q 4 (c (q . 1) (c 2 (c 5 ()))) 11) (a 5 (c 2 (c () (c 11 ())))))
         MOCK_OWNERSHIP_LAYER: Program = Program.fromhex(
-            "ff02ffff01ff04ffff04ffff0101ffff04ff02ffff04ff05ff80808080ff0b80ffff02ff05ffff04ff02ffff04ff80ffff04ff0bff808080808080"  # noqa: E501
+            "ff02ffff01ff04ffff04ffff0101ffff04ff02ffff04ff05ff80808080ff0b80ffff02ff05ffff04ff02ffff04ff80ffff04ff0bff808080808080"
         )
         # Create it with mock singleton info
         transfer_program: Program = create_did_tp(MOCK_SINGLETON_MOD_HASH, MOCK_LAUNCHER_HASH)
@@ -210,10 +210,10 @@ async def test_did_tp(cost_logger: CostLogger) -> None:
         my_coin_id: bytes32 = eml_coin.name()
         new_metadata: Program = Program.to("SUCCESS")
         new_tp_hash = Program.to("NEW TP").get_tree_hash()
-        bad_data: bytes32 = bytes32([0] * 32)
+        bad_data: bytes32 = bytes32.zeros
 
         # Try to update metadata and tp without any announcement
-        result: Tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
+        result: tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
             WalletSpendBundle(
                 [
                     make_spend(
@@ -327,7 +327,7 @@ async def test_viral_backdoor(cost_logger: CostLogger) -> None:
         )[0].coin
 
         # Reveal the wrong puzzle
-        result: Tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
+        result: tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
             WalletSpendBundle(
                 [
                     make_spend(
@@ -354,7 +354,7 @@ async def test_viral_backdoor(cost_logger: CostLogger) -> None:
                         p2_either_puzzle,
                         solve_viral_backdoor(
                             hidden_puzzle,
-                            Program.to(bytes32([0] * 32)),
+                            Program.to(bytes32.zeros),
                             hidden=True,
                         ),
                     )
@@ -365,7 +365,7 @@ async def test_viral_backdoor(cost_logger: CostLogger) -> None:
         assert result == (MempoolInclusionStatus.FAILED, Err.ASSERT_ANNOUNCE_CONSUMED_FAILED)
 
         # Spend the inner puzzle
-        brick_hash: bytes32 = bytes32([0] * 32)
+        brick_hash: bytes32 = bytes32.zeros
         wrapped_brick_hash: bytes32 = create_viral_backdoor(
             hidden_puzzle_hash,
             brick_hash,
@@ -399,7 +399,7 @@ async def test_viral_backdoor(cost_logger: CostLogger) -> None:
 @pytest.mark.parametrize("num_proofs", range(1, 6))
 async def test_proofs_checker(cost_logger: CostLogger, num_proofs: int) -> None:
     async with sim_and_client() as (sim, client):
-        flags: List[str] = [str(i) for i in range(0, num_proofs)]
+        flags: list[str] = [str(i) for i in range(0, num_proofs)]
         proofs_checker: ProofsChecker = ProofsChecker(flags)
 
         # (mod (PROOFS_CHECKER proofs) (if (a PROOFS_CHECKER (list proofs)) () (x)))
@@ -415,7 +415,7 @@ async def test_proofs_checker(cost_logger: CostLogger, num_proofs: int) -> None:
 
         block_height: uint32 = sim.block_height
         for i, proof_list in enumerate(itertools.permutations(flags, num_proofs)):
-            result: Tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
+            result: tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
                 cost_logger.add_cost(
                     f"Proofs Checker only - num_proofs: {num_proofs} - permutation: {i}",
                     WalletSpendBundle(
@@ -504,9 +504,9 @@ async def test_vc_lifecycle(test_syncing: bool, cost_logger: CostLogger) -> None
             [vc_fund_coin],
             launcher_id,
             ACS_PH,
-            [bytes32([0] * 32)],
+            [bytes32.zeros],
         )
-        result: Tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
+        result: tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
             cost_logger.add_cost(
                 "Launch VC",
                 WalletSpendBundle(
@@ -612,7 +612,7 @@ async def test_vc_lifecycle(test_syncing: bool, cost_logger: CostLogger) -> None
             else:
                 proofs = ["test", "test2"]
             proofs_checker: ProofsChecker = ProofsChecker(proofs)
-            AUTHORIZED_PROVIDERS: List[bytes32] = [launcher_id]
+            AUTHORIZED_PROVIDERS: list[bytes32] = [launcher_id]
             dpuz_1, launch_crcat_spend_1, cr_1 = CRCAT.launch(
                 cr_coin_1,
                 Payment(ACS_PH, uint64(cr_coin_1.amount), []),
@@ -716,7 +716,7 @@ async def test_vc_lifecycle(test_syncing: bool, cost_logger: CostLogger) -> None
                             62,
                             (
                                 cr_1.expected_announcement()
-                                if error not in ["use_malicious_cats", "attempt_honest_cat_piggyback"]
+                                if error not in {"use_malicious_cats", "attempt_honest_cat_piggyback"}
                                 else malicious_cr_1.expected_announcement()
                             ),
                         ],
@@ -724,7 +724,7 @@ async def test_vc_lifecycle(test_syncing: bool, cost_logger: CostLogger) -> None
                             62,
                             (
                                 cr_2.expected_announcement()
-                                if error not in ["use_malicious_cats", "attempt_honest_cat_piggyback"]
+                                if error not in {"use_malicious_cats", "attempt_honest_cat_piggyback"}
                                 else malicious_cr_2.expected_announcement()
                             ),
                         ],
@@ -755,7 +755,7 @@ async def test_vc_lifecycle(test_syncing: bool, cost_logger: CostLogger) -> None
                 else:
                     vc = new_vc
                 await sim.farm_block()
-            elif error in ["forget_vc", "use_malicious_cats", "attempt_honest_cat_piggyback"]:
+            elif error in {"forget_vc", "use_malicious_cats", "attempt_honest_cat_piggyback"}:
                 assert result == (MempoolInclusionStatus.FAILED, Err.ASSERT_ANNOUNCE_CONSUMED_FAILED)
             elif error == "make_banned_announcement":
                 assert result == (MempoolInclusionStatus.FAILED, Err.GENERATOR_RUNTIME_ERROR)