chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/_tests/wallet/dao_wallet/test_dao_wallets.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import time
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Optional, Union
 
 import pytest
 
@@ -32,17 +33,17 @@ from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 
 
-async def get_proposal_state(wallet: DAOWallet, index: int) -> Tuple[Optional[bool], Optional[bool]]:
+async def get_proposal_state(wallet: DAOWallet, index: int) -> tuple[Optional[bool], Optional[bool]]:
     return wallet.dao_info.proposals_list[index].passed, wallet.dao_info.proposals_list[index].closed
 
 
 async def rpc_state(
     timeout: float,
     async_function: Callable[[Any], Any],
-    params: List[Union[int, Dict[str, Any]]],
-    condition_func: Callable[[Dict[str, Any]], Any],
+    params: list[Union[int, dict[str, Any]]],
+    condition_func: Callable[[dict[str, Any]], Any],
     result: Optional[Any] = None,
-) -> Union[bool, Dict[str, Any]]:  # pragma: no cover
+) -> Union[bool, dict[str, Any]]:  # pragma: no cover
     __tracebackhide__ = True
 
     timeout = adjusted_timeout(timeout=timeout)
@@ -221,7 +222,7 @@ async def test_dao_creation(self_hostname: str, two_wallet_nodes: OldSimulatorsA
     coins = await dao_cat_wallet_0.advanced_select_coins(1, fake_proposal_id)
     assert len(coins) > 0
     # check that we have selected the coin from dao_cat_wallet
-    assert list(coins)[0].coin.amount == dao_cat_amt
+    assert coins[0].coin.amount == dao_cat_amt
 
     # send some cats from wallet_0 to wallet_1 so we can test voting
     async with cat_wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
@@ -1031,7 +1032,7 @@ async def test_dao_proposal_partial_vote(
     await full_node_api.wait_for_wallets_synced(wallet_nodes=[wallet_node_0, wallet_node_1], timeout=30)
 
     # Create a mint proposal
-    recipient_puzzle_hash = await cat_wallet_1.get_new_inner_hash()
+    recipient_puzzle_hash = await cat_wallet_1.standard_wallet.get_puzzle_hash(new=False)
     new_mint_amount = uint64(500)
     mint_proposal_inner = await generate_mint_proposal_innerpuz(
         treasury_id,
@@ -1103,7 +1104,7 @@ async def test_dao_proposal_partial_vote(
     await time_out_assert(20, cat_wallet_1.get_spendable_balance, balance + new_mint_amount)
     # Can we spend the newly minted CATs?
     old_balance = await cat_wallet_0.get_spendable_balance()
-    ph_0 = await cat_wallet_0.get_new_inner_hash()
+    ph_0 = await cat_wallet_0.standard_wallet.get_puzzle_hash(new=False)
     async with cat_wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await cat_wallet_1.generate_signed_transaction([balance + new_mint_amount], [ph_0], action_scope)
     await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
@@ -1626,7 +1627,7 @@ async def test_dao_rpc_api(self_hostname: str, two_wallet_nodes: Any, trusted: A
 async def test_dao_rpc_client(
     two_wallet_nodes_services: SimulatorsAndWalletsServices, trusted: bool, self_hostname: str
 ) -> None:
-    [full_node_service], wallet_services, bt = two_wallet_nodes_services
+    [full_node_service], wallet_services, _bt = two_wallet_nodes_services
     full_node_api = full_node_service._api
     full_node_server = full_node_api.full_node.server
     wallet_node_0 = wallet_services[0]._node
@@ -1661,22 +1662,26 @@ async def test_dao_rpc_client(
     assert wallet_services[0].rpc_server is not None
     assert wallet_services[1].rpc_server is not None
 
-    client_0 = await WalletRpcClient.create(
-        self_hostname,
-        wallet_services[0].rpc_server.listen_port,
-        wallet_services[0].root_path,
-        wallet_services[0].config,
-    )
-    await validate_get_routes(client_0, wallet_services[0].rpc_server.rpc_api)
-    client_1 = await WalletRpcClient.create(
-        self_hostname,
-        wallet_services[1].rpc_server.listen_port,
-        wallet_services[1].root_path,
-        wallet_services[1].config,
-    )
-    await validate_get_routes(client_1, wallet_services[1].rpc_server.rpc_api)
+    async with contextlib.AsyncExitStack() as exit_stack:
+        client_0 = await exit_stack.enter_async_context(
+            WalletRpcClient.create_as_context(
+                self_hostname,
+                wallet_services[0].rpc_server.listen_port,
+                wallet_services[0].root_path,
+                wallet_services[0].config,
+            )
+        )
+        await validate_get_routes(client_0, wallet_services[0].rpc_server.rpc_api)
+        client_1 = await exit_stack.enter_async_context(
+            WalletRpcClient.create_as_context(
+                self_hostname,
+                wallet_services[1].rpc_server.listen_port,
+                wallet_services[1].root_path,
+                wallet_services[1].config,
+            )
+        )
+        await validate_get_routes(client_1, wallet_services[1].rpc_server.rpc_api)
 
-    try:
         cat_amt = uint64(150000)
         amount_of_cats = uint64(cat_amt * 2)
         dao_rules = DAORules(
@@ -2000,12 +2005,6 @@ async def test_dao_rpc_client(
         filter_amount_resp = await client_0.dao_adjust_filter_level(wallet_id=dao_id_0, filter_level=30)
         assert filter_amount_resp["dao_info"]["filter_below_vote_amount"] == 30
 
-    finally:
-        client_0.close()
-        client_1.close()
-        await client_0.await_closed()
-        await client_1.await_closed()
-
 
 @pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
 @pytest.mark.parametrize(
@@ -2016,7 +2015,7 @@ async def test_dao_rpc_client(
 async def test_dao_complex_spends(
     two_wallet_nodes_services: SimulatorsAndWalletsServices, trusted: bool, self_hostname: str
 ) -> None:
-    [full_node_service], wallet_services, bt = two_wallet_nodes_services
+    [full_node_service], wallet_services, _bt = two_wallet_nodes_services
     full_node_api = full_node_service._api
     full_node_server = full_node_api.full_node.server
     wallet_node_0 = wallet_services[0]._node
@@ -2051,22 +2050,26 @@ async def test_dao_complex_spends(
     assert wallet_services[0].rpc_server is not None
     assert wallet_services[1].rpc_server is not None
 
-    client_0 = await WalletRpcClient.create(
-        self_hostname,
-        wallet_services[0].rpc_server.listen_port,
-        wallet_services[0].root_path,
-        wallet_services[0].config,
-    )
-    await validate_get_routes(client_0, wallet_services[0].rpc_server.rpc_api)
-    client_1 = await WalletRpcClient.create(
-        self_hostname,
-        wallet_services[1].rpc_server.listen_port,
-        wallet_services[1].root_path,
-        wallet_services[1].config,
-    )
-    await validate_get_routes(client_1, wallet_services[1].rpc_server.rpc_api)
+    async with contextlib.AsyncExitStack() as exit_stack:
+        client_0 = await exit_stack.enter_async_context(
+            WalletRpcClient.create_as_context(
+                self_hostname,
+                wallet_services[0].rpc_server.listen_port,
+                wallet_services[0].root_path,
+                wallet_services[0].config,
+            )
+        )
+        await validate_get_routes(client_0, wallet_services[0].rpc_server.rpc_api)
+        client_1 = await exit_stack.enter_async_context(
+            WalletRpcClient.create_as_context(
+                self_hostname,
+                wallet_services[1].rpc_server.listen_port,
+                wallet_services[1].root_path,
+                wallet_services[1].config,
+            )
+        )
+        await validate_get_routes(client_1, wallet_services[1].rpc_server.rpc_api)
 
-    try:
         cat_amt = uint64(300000)
         dao_rules = DAORules(
             proposal_timelock=uint64(2),
@@ -2380,12 +2383,6 @@ async def test_dao_complex_spends(
             1,
         )
 
-    finally:
-        client_0.close()
-        client_1.close()
-        await client_0.await_closed()
-        await client_1.await_closed()
-
 
 @pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
 @pytest.mark.parametrize(
@@ -2617,7 +2614,7 @@ async def test_dao_concurrency(self_hostname: str, three_wallet_nodes: OldSimula
 async def test_dao_cat_exits(
     two_wallet_nodes_services: SimulatorsAndWalletsServices, trusted: bool, self_hostname: str
 ) -> None:
-    [full_node_service], wallet_services, bt = two_wallet_nodes_services
+    [full_node_service], wallet_services, _bt = two_wallet_nodes_services
     full_node_api = full_node_service._api
     full_node_server = full_node_api.full_node.server
     wallet_node_0 = wallet_services[0]._node
@@ -2651,22 +2648,26 @@ async def test_dao_cat_exits(
     assert wallet_services[0].rpc_server is not None
     assert wallet_services[1].rpc_server is not None
 
-    client_0 = await WalletRpcClient.create(
-        self_hostname,
-        wallet_services[0].rpc_server.listen_port,
-        wallet_services[0].root_path,
-        wallet_services[0].config,
-    )
-    await validate_get_routes(client_0, wallet_services[0].rpc_server.rpc_api)
-    client_1 = await WalletRpcClient.create(
-        self_hostname,
-        wallet_services[1].rpc_server.listen_port,
-        wallet_services[1].root_path,
-        wallet_services[1].config,
-    )
-    await validate_get_routes(client_1, wallet_services[1].rpc_server.rpc_api)
+    async with contextlib.AsyncExitStack() as exit_stack:
+        client_0 = await exit_stack.enter_async_context(
+            WalletRpcClient.create_as_context(
+                self_hostname,
+                wallet_services[0].rpc_server.listen_port,
+                wallet_services[0].root_path,
+                wallet_services[0].config,
+            )
+        )
+        await validate_get_routes(client_0, wallet_services[0].rpc_server.rpc_api)
+        client_1 = await exit_stack.enter_async_context(
+            WalletRpcClient.create_as_context(
+                self_hostname,
+                wallet_services[1].rpc_server.listen_port,
+                wallet_services[1].root_path,
+                wallet_services[1].config,
+            )
+        )
+        await validate_get_routes(client_1, wallet_services[1].rpc_server.rpc_api)
 
-    try:
         cat_amt = uint64(150000)
         dao_rules = DAORules(
             proposal_timelock=uint64(8),
@@ -2693,7 +2694,12 @@ async def test_dao_cat_exits(
         dao_id_0 = dao_wallet_res_0.wallet_id
         cat_wallet_0 = wallet_node_0.wallet_state_manager.wallets[dao_wallet_res_0.cat_wallet_id]
         dao_cat_wallet_0 = wallet_node_0.wallet_state_manager.wallets[dao_wallet_res_0.dao_cat_wallet_id]
-        txs = await wallet_0.wallet_state_manager.tx_store.get_all_unconfirmed()
+        ltxs = await wallet_0.wallet_state_manager.tx_store.get_all_unconfirmed()
+        txs: list[TransactionRecord] = []
+        for ltx in ltxs:
+            tx = await wallet_0.wallet_state_manager.tx_store.get_transaction_record(ltx.name)
+            assert tx is not None
+            txs.append(tx)
         await full_node_api.wait_transaction_records_entered_mempool(records=txs, timeout=60)
         await full_node_api.process_transaction_records(records=txs, timeout=60)
         await full_node_api.process_all_wallet_transactions(wallet_0, 60)
@@ -2786,12 +2792,6 @@ async def test_dao_cat_exits(
         await time_out_assert(20, dao_cat_wallet_0.get_confirmed_balance, 0)
         await time_out_assert(20, cat_wallet_0.get_confirmed_balance, cat_amt)
 
-    finally:
-        client_0.close()
-        client_1.close()
-        await client_0.await_closed()
-        await client_1.await_closed()
-
 
 @pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
 @pytest.mark.parametrize(

chia/_tests/wallet/db_wallet/test_db_graftroot.py

@@ -1,11 +1,9 @@
 from __future__ import annotations
 
-from typing import Dict, List, Tuple
-
 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
@@ -31,7 +29,7 @@ GRAFTROOT_MOD = load_clvm("graftroot_dl_offers.clsp", package_or_requirement="ch
 #   (recurse solution ())
 # )
 ACS = Program.fromhex(
-    "ff02ffff01ff02ff02ffff04ff02ffff04ff03ffff01ff8080808080ffff04ffff01ff02ffff03ff05ffff01ff02ff02ffff04ff02ffff04ff0dffff04ff09ff8080808080ffff010b80ff0180ff018080"  # noqa
+    "ff02ffff01ff02ff02ffff04ff02ffff04ff03ffff01ff8080808080ffff04ffff01ff02ffff03ff05ffff01ff02ff02ffff04ff02ffff04ff0dffff04ff09ff8080808080ffff010b80ff0180ff018080"
 )
 ACS_PH = ACS.get_tree_hash()
 
@@ -42,11 +40,11 @@ NIL_PH = Program.to(None).get_tree_hash()
 async def test_graftroot(cost_logger: CostLogger) -> None:
     async with sim_and_client() as (sim, sim_client):
         # Create the coin we're testing
-        all_values: List[bytes32] = [bytes32([x] * 32) for x in range(0, 100)]
+        all_values: list[bytes32] = [bytes32([x] * 32) for x in range(0, 100)]
         root, proofs = build_merkle_tree(all_values)
         p2_conditions = Program.to((1, [[51, ACS_PH, 0]]))  # An coin to create to make sure this hits the blockchain
-        desired_key_values = ((bytes32([0] * 32), bytes32([1] * 32)), (bytes32([7] * 32), bytes32([8] * 32)))
-        desired_row_hashes: List[bytes32] = [build_merkle_tree_from_binary_tree(kv)[0] for kv in desired_key_values]
+        desired_key_values = ((bytes32.zeros, bytes32([1] * 32)), (bytes32([7] * 32), bytes32([8] * 32)))
+        desired_row_hashes: list[bytes32] = [build_merkle_tree_from_binary_tree(kv)[0] for kv in desired_key_values]
         fake_struct: Program = Program.to((ACS_PH, NIL_PH))
         graftroot_puzzle: Program = GRAFTROOT_MOD.curry(
             # Do everything twice to test depending on multiple singleton updates
@@ -61,21 +59,21 @@ async def test_graftroot(cost_logger: CostLogger) -> None:
         ].coin
 
         # Build some merkle trees that won't satidy the requirements
-        def filter_all(values: List[bytes32]) -> List[bytes32]:
+        def filter_all(values: list[bytes32]) -> list[bytes32]:
             return [h for i, h in enumerate(values) if (h, values[min(i, i + 1)]) not in desired_key_values]
 
-        def filter_to_only_one(values: List[bytes32]) -> List[bytes32]:
+        def filter_to_only_one(values: list[bytes32]) -> list[bytes32]:
             return [h for i, h in enumerate(values) if (h, values[min(i, i + 1)]) not in desired_key_values[1:]]
 
         # And one that will
-        def filter_none(values: List[bytes32]) -> List[bytes32]:
+        def filter_none(values: list[bytes32]) -> list[bytes32]:
             return values
 
         for list_filter in (filter_all, filter_to_only_one, filter_none):
             # Create the "singleton"
             filtered_values = list_filter(all_values)
             root, proofs = build_merkle_tree(filtered_values)
-            filtered_row_hashes: Dict[bytes32, Tuple[int, List[bytes32]]] = {
+            filtered_row_hashes: dict[bytes32, tuple[int, list[bytes32]]] = {
                 simplify_merkle_proof(v, (proofs[v][0], [proofs[v][1][0]])): (proofs[v][0] >> 1, proofs[v][1][1:])
                 for v in filtered_values
             }
@@ -131,7 +129,7 @@ async def test_graftroot(cost_logger: CostLogger) -> None:
                 # try with a bad merkle root announcement
                 new_fake_spend = make_spend(
                     fake_coin,
-                    ACS.curry(fake_struct, ACS.curry(ACS_PH, (bytes32([0] * 32), None), None, None)),
+                    ACS.curry(fake_struct, ACS.curry(ACS_PH, (bytes32.zeros, None), None, None)),
                     Program.to([[[62, "$"]]]),
                 )
                 new_final_bundle = WalletSpendBundle([new_fake_spend, graftroot_spend], G2Element())

chia/_tests/wallet/db_wallet/test_dl_offers.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, List, Tuple
+from typing import Any
 
 import pytest
 
@@ -31,9 +31,9 @@ async def get_trade_and_status(trade_manager: Any, trade: TradeRecord) -> TradeS
     return TradeStatus(trade_rec.status)
 
 
-def get_parent_branch(value: bytes32, proof: Tuple[int, List[bytes32]]) -> Tuple[bytes32, Tuple[int, List[bytes32]]]:
+def get_parent_branch(value: bytes32, proof: tuple[int, list[bytes32]]) -> tuple[bytes32, tuple[int, list[bytes32]]]:
     branch: bytes32 = simplify_merkle_proof(value, (proof[0], [proof[1][0]]))
-    new_proof: Tuple[int, List[bytes32]] = (proof[0] >> 1, proof[1][1:])
+    new_proof: tuple[int, list[bytes32]] = (proof[0] >> 1, proof[1][1:])
     return branch, new_proof
 
 
@@ -136,7 +136,7 @@ async def test_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
         ]
     }
 
-    [maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
         [Offer.from_bytes(offer_maker.offer)]
     )
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
@@ -263,7 +263,7 @@ async def test_dl_offer_cancellation(wallets_prefarm: Any, trusted: bool) -> Non
 
     addition = bytes32([101] * 32)
     ROWS.append(addition)
-    root, proofs = build_merkle_tree(ROWS)
+    root, _proofs = build_merkle_tree(ROWS)
 
     async with trade_manager.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
         success, offer, error = await trade_manager.create_offer_for_ids(
@@ -414,7 +414,7 @@ async def test_multiple_dl_offers(wallets_prefarm: Any, trusted: bool) -> None:
     assert success is True
     assert offer_maker is not None
 
-    [maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
         [Offer.from_bytes(offer_maker.offer)]
     )
     async with trade_manager_taker.wallet_state_manager.new_action_scope(

chia/_tests/wallet/db_wallet/test_dl_wallet.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import dataclasses
-from typing import Any, List
+from typing import Any
 
 import pytest
 
@@ -426,7 +426,7 @@ class TestDLWallet:
         assert current_record != record_1
         async with dl_wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
             await dl_wallet_0.create_update_state_spend(
-                launcher_id, bytes32([0] * 32), action_scope, fee=uint64(2000000000000)
+                launcher_id, bytes32.zeros, action_scope, fee=uint64(2000000000000)
             )
         update_txs = action_scope.side_effects.transactions
         record_0 = await dl_wallet_0.get_latest_singleton(launcher_id)
@@ -569,35 +569,35 @@ async def test_mirrors(wallets_prefarm: Any, trusted: bool) -> None:
         dl_wallet_2 = await DataLayerWallet.create_new_dl_wallet(wsm_2)
 
     async with dl_wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        launcher_id_1 = await dl_wallet_1.generate_new_reporter(bytes32([0] * 32), action_scope)
+        launcher_id_1 = await dl_wallet_1.generate_new_reporter(bytes32.zeros, action_scope)
     assert await dl_wallet_1.get_latest_singleton(launcher_id_1) is not None
     await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_1, launcher_id_1, bytes32([0] * 32))
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_1, launcher_id_1, bytes32.zeros)
 
     async with dl_wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        launcher_id_2 = await dl_wallet_2.generate_new_reporter(bytes32([0] * 32), action_scope)
+        launcher_id_2 = await dl_wallet_2.generate_new_reporter(bytes32.zeros, action_scope)
     assert await dl_wallet_2.get_latest_singleton(launcher_id_2) is not None
     await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_2, launcher_id_2, bytes32([0] * 32))
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_2, launcher_id_2, bytes32.zeros)
 
     peer_1 = wallet_node_1.get_full_node_peer()
     await dl_wallet_1.track_new_launcher_id(launcher_id_2, peer_1)
     peer_2 = wallet_node_2.get_full_node_peer()
     await dl_wallet_2.track_new_launcher_id(launcher_id_1, peer_2)
-    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_1, launcher_id_2, bytes32([0] * 32))
-    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_2, launcher_id_1, bytes32([0] * 32))
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_1, launcher_id_2, bytes32.zeros)
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet_2, launcher_id_1, bytes32.zeros)
 
     async with dl_wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await dl_wallet_1.create_new_mirror(
             launcher_id_2, uint64(3), [b"foo", b"bar"], action_scope, fee=uint64(1_999_999_999_999)
         )
-    additions: List[Coin] = []
+    additions: list[Coin] = []
     for tx in action_scope.side_effects.transactions:
         if tx.spend_bundle is not None:
             additions.extend(tx.spend_bundle.additions())
     await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
 
-    mirror_coin: Coin = [c for c in additions if c.puzzle_hash == create_mirror_puzzle().get_tree_hash()][0]
+    mirror_coin: Coin = next(c for c in additions if c.puzzle_hash == create_mirror_puzzle().get_tree_hash())
     mirror = Mirror(
         bytes32(mirror_coin.name()),
         bytes32(launcher_id_2),
@@ -648,7 +648,7 @@ async def test_datalayer_reorgs(wallet_environments: WalletTestFramework) -> Non
         dl_wallet = await DataLayerWallet.create_new_dl_wallet(env.wallet_state_manager)
 
     async with dl_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        launcher_id = await dl_wallet.generate_new_reporter(bytes32([0] * 32), action_scope)
+        launcher_id = await dl_wallet.generate_new_reporter(bytes32.zeros, action_scope)
 
     await wallet_environments.process_pending_states(
         [
@@ -676,16 +676,16 @@ async def test_datalayer_reorgs(wallet_environments: WalletTestFramework) -> Non
             )
         ]
     )
-    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet, launcher_id, bytes32([0] * 32))
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet, launcher_id, bytes32.zeros)
 
     height = full_node_api.full_node.blockchain.get_peak_height()
     assert height is not None
     await full_node_api.reorg_from_index_to_new_index(
-        ReorgProtocol(uint32(height - 1), uint32(height + 1), bytes32([0] * 32), None)
+        ReorgProtocol(uint32(height - 1), uint32(height + 1), bytes32.zeros, None)
     )
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=5)
 
-    await time_out_assert(15, is_singleton_confirmed_and_root, False, dl_wallet, launcher_id, bytes32([0] * 32))
+    await time_out_assert(15, is_singleton_confirmed_and_root, False, dl_wallet, launcher_id, bytes32.zeros)
 
     await wallet_environments.process_pending_states(
         [
@@ -713,7 +713,7 @@ async def test_datalayer_reorgs(wallet_environments: WalletTestFramework) -> Non
             )
         ]
     )
-    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet, launcher_id, bytes32([0] * 32))
+    await time_out_assert(15, is_singleton_confirmed_and_root, True, dl_wallet, launcher_id, bytes32.zeros)
 
     async with dl_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await dl_wallet.create_update_state_spend(launcher_id, bytes32([2] * 32), action_scope)
@@ -737,11 +737,11 @@ async def test_datalayer_reorgs(wallet_environments: WalletTestFramework) -> Non
     height = full_node_api.full_node.blockchain.get_peak_height()
     assert height is not None
     await full_node_api.reorg_from_index_to_new_index(
-        ReorgProtocol(uint32(height - 1), uint32(height + 1), bytes32([0] * 32), None)
+        ReorgProtocol(uint32(height - 1), uint32(height + 1), bytes32.zeros, None)
     )
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=5)
 
-    await time_out_assert(15, is_singleton_confirmed_and_root, False, dl_wallet, launcher_id, bytes32([0] * 32))
+    await time_out_assert(15, is_singleton_confirmed_and_root, False, dl_wallet, launcher_id, bytes32.zeros)
 
     await wallet_environments.process_pending_states(
         [
@@ -790,7 +790,7 @@ async def test_datalayer_reorgs(wallet_environments: WalletTestFramework) -> Non
     height = full_node_api.full_node.blockchain.get_peak_height()
     assert height is not None
     await full_node_api.reorg_from_index_to_new_index(
-        ReorgProtocol(uint32(height - 1), uint32(height + 1), bytes32([0] * 32), None)
+        ReorgProtocol(uint32(height - 1), uint32(height + 1), bytes32.zeros, None)
     )
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=5)