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

chia/_tests/wallet/test_singleton_lifecycle_fast.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type, TypeVar, cast, get_args, get_origin
+from typing import Any, Callable, Optional, TypeVar, cast, get_args, get_origin
 
 from chia_rs import G1Element, G2Element
 from clvm_tools import binutils
@@ -35,12 +35,12 @@ ANYONE_CAN_SPEND_WITH_PADDING_PUZZLE_HASH = Program.to(binutils.assemble("(a (q
 
 POOL_REWARD_PREFIX_MAINNET = bytes32.fromhex("ccd5bb71183532bff220ba46c268991a00000000000000000000000000000000")
 
-MAX_BLOCK_COST_CLVM = int(1e18)
+MAX_BLOCK_COST_CLVM = 10**18
 
 T = TypeVar("T")
 
 
-def satisfies_hint(obj: T, type_hint: Type[T]) -> bool:
+def satisfies_hint(obj: T, type_hint: type[T]) -> bool:
     """
     Check if an object satisfies a type hint.
     This is a simplified version of `isinstance` that also handles generic types.
@@ -56,7 +56,7 @@ def satisfies_hint(obj: T, type_hint: Type[T]) -> bool:
             if not isinstance(obj, origin):
                 return False
             if len(args) > 0:
-                # Tuple[T, ...] gets handled just like List[T]
+                # tuple[T, ...] gets handled just like list[T]
                 if origin is list or (origin is tuple and args[-1] is Ellipsis):
                     object_hint_pairs.extend((item, args[0]) for item in obj)
                 elif origin is tuple:
@@ -75,7 +75,7 @@ def satisfies_hint(obj: T, type_hint: Type[T]) -> bool:
 
 class PuzzleDB:
     def __init__(self) -> None:
-        self._db: Dict[bytes32, Program] = {}
+        self._db: dict[bytes32, Program] = {}
 
     def add_puzzle(self, puzzle: Program) -> None:
         self._db[puzzle.get_tree_hash()] = Program.from_bytes(bytes(puzzle))
@@ -84,7 +84,7 @@ class PuzzleDB:
         return self._db.get(puzzle_hash)
 
 
-def from_kwargs(kwargs: Dict[str, Any], key: str, type_info: Type[T]) -> T:
+def from_kwargs(kwargs: dict[str, Any], key: str, type_info: type[T]) -> T:
     """Raise an exception if `kwargs[key]` is missing or the wrong type"""
     if key not in kwargs:
         raise ValueError(f"`{key}` missing in call to `solve`")
@@ -93,7 +93,7 @@ def from_kwargs(kwargs: Dict[str, Any], key: str, type_info: Type[T]) -> T:
     return cast(T, kwargs[key])
 
 
-Solver_F = Callable[["Solver", PuzzleDB, List[Program], Any], Program]
+Solver_F = Callable[["Solver", PuzzleDB, list[Program], Any], Program]
 
 
 class Solver:
@@ -102,14 +102,14 @@ class Solver:
     """
 
     def __init__(self) -> None:
-        self.solvers_by_puzzle_hash: Dict[bytes32, Solver_F] = {}
+        self.solvers_by_puzzle_hash: dict[bytes32, Solver_F] = {}
 
     def register_solver(self, puzzle_hash: bytes32, solver_f: Solver_F) -> None:
         if puzzle_hash in self.solvers_by_puzzle_hash:
             raise ValueError(f"solver registered for {puzzle_hash}")
         self.solvers_by_puzzle_hash[puzzle_hash] = solver_f
 
-    def solve(self, puzzle_db: PuzzleDB, puzzle: Program, **kwargs: Dict[str, Any]) -> Program:
+    def solve(self, puzzle_db: PuzzleDB, puzzle: Program, **kwargs: dict[str, Any]) -> Program:
         """
         The legal values and types for `kwargs` depends on the underlying solver
         that's invoked. The `kwargs` are passed through to any inner solvers
@@ -128,34 +128,34 @@ class Solver:
         raise ValueError("can't solve")
 
 
-def solve_launcher(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]) -> Program:
+def solve_launcher(solver: Solver, puzzle_db: PuzzleDB, args: list[Program], kwargs: dict[str, Any]) -> Program:
     launcher_amount = from_kwargs(kwargs, "launcher_amount", uint64)
     destination_puzzle_hash = from_kwargs(kwargs, "destination_puzzle_hash", bytes32)
-    metadata = from_kwargs(kwargs, "metadata", List[Tuple[str, str]])
+    metadata = from_kwargs(kwargs, "metadata", list[tuple[str, str]])
     solution = Program.to([destination_puzzle_hash, launcher_amount, metadata])
     return solution
 
 
-def solve_anyone_can_spend(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]) -> Program:
+def solve_anyone_can_spend(solver: Solver, puzzle_db: PuzzleDB, args: list[Program], kwargs: dict[str, Any]) -> Program:
     """
     This is the anyone-can-spend puzzle `1`. Note that farmers can easily steal this coin, so don't use
     it except for testing.
     """
-    conditions = from_kwargs(kwargs, "conditions", List[Program])
+    conditions = from_kwargs(kwargs, "conditions", list[Program])
     solution = Program.to(conditions)
     return solution
 
 
 def solve_anyone_can_spend_with_padding(
-    solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]
+    solver: Solver, puzzle_db: PuzzleDB, args: list[Program], kwargs: dict[str, Any]
 ) -> Program:
     """This is the puzzle `(a (q . 1) 3)`. It's only for testing."""
-    conditions = from_kwargs(kwargs, "conditions", List[Program])
+    conditions = from_kwargs(kwargs, "conditions", list[Program])
     solution = Program.to((0, conditions))
     return solution
 
 
-def solve_singleton(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]) -> Program:
+def solve_singleton(solver: Solver, puzzle_db: PuzzleDB, args: list[Program], kwargs: dict[str, Any]) -> Program:
     """
     `lineage_proof`: a `Program` that proves the parent is also a singleton (or the launcher).
     `coin_amount`: a necessarily-odd value of mojos in this coin.
@@ -168,7 +168,7 @@ def solve_singleton(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kw
     return solution
 
 
-def solve_pool_member(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]) -> Program:
+def solve_pool_member(solver: Solver, puzzle_db: PuzzleDB, args: list[Program], kwargs: dict[str, Any]) -> Program:
     pool_member_spend_type = from_kwargs(kwargs, "pool_member_spend_type", str)
     allowable = ["to-waiting-room", "claim-p2-nft"]
     if pool_member_spend_type not in allowable:
@@ -185,7 +185,7 @@ def solve_pool_member(solver: Solver, puzzle_db: PuzzleDB, args: List[Program],
 
 
 def solve_pool_waiting_room(
-    solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]
+    solver: Solver, puzzle_db: PuzzleDB, args: list[Program], kwargs: dict[str, Any]
 ) -> Program:
     pool_leaving_spend_type = from_kwargs(kwargs, "pool_leaving_spend_type", str)
     allowable = ["exit-waiting-room", "claim-p2-nft"]
@@ -193,7 +193,7 @@ def solve_pool_waiting_room(
         raise ValueError(f"`pool_leaving_spend_type` must be one of {'/'.join(allowable)} for POOL_MEMBER puzzle")
     exit_waiting_room = pool_leaving_spend_type == "exit-waiting-room"
     if exit_waiting_room:
-        key_value_list = from_kwargs(kwargs, "key_value_list", List[Tuple[str, str]])
+        key_value_list = from_kwargs(kwargs, "key_value_list", list[tuple[str, str]])
         destination_puzzle_hash = from_kwargs(kwargs, "destination_puzzle_hash", bytes32)
         return Program.to([0, 1, key_value_list, destination_puzzle_hash])
     # it's an "absorb_pool_reward" type
@@ -203,7 +203,7 @@ def solve_pool_waiting_room(
     return solution
 
 
-def solve_p2_singleton(solver: Solver, puzzle_db: PuzzleDB, args: List[Program], kwargs: Dict[str, Any]) -> Program:
+def solve_p2_singleton(solver: Solver, puzzle_db: PuzzleDB, args: list[Program], kwargs: dict[str, Any]) -> Program:
     p2_singleton_spend_type = from_kwargs(kwargs, "p2_singleton_spend_type", str)
     allowable = ["claim-p2-nft", "delayed-spend"]
     if p2_singleton_spend_type not in allowable:
@@ -211,7 +211,7 @@ def solve_p2_singleton(solver: Solver, puzzle_db: PuzzleDB, args: List[Program],
     claim_p2_nft = p2_singleton_spend_type == "claim-p2-nft"
     if claim_p2_nft:
         singleton_inner_puzzle_hash = from_kwargs(kwargs, "singleton_inner_puzzle_hash", bytes32)
-        p2_singleton_coin_name = from_kwargs(kwargs, "p2_singleton_coin_name", bytes)
+        p2_singleton_coin_name = from_kwargs(kwargs, "p2_singleton_coin_name", bytes32)
         solution = Program.to([singleton_inner_puzzle_hash, p2_singleton_coin_name])
         return solution
     raise ValueError("can't solve `delayed-spend` yet")
@@ -261,7 +261,7 @@ class SingletonWallet:
         )
         return make_spend(coin, puzzle_reveal, solution)
 
-    def update_state(self, puzzle_db: PuzzleDB, removals: List[CoinSpend]) -> int:
+    def update_state(self, puzzle_db: PuzzleDB, removals: list[CoinSpend]) -> int:
         state_change_count = 0
         current_coin_name = self.current_state.name()
         for coin_spend in removals:
@@ -303,9 +303,9 @@ def launcher_conditions_and_spend_bundle(
     parent_coin_id: bytes32,
     launcher_amount: uint64,
     initial_singleton_inner_puzzle: Program,
-    metadata: List[Tuple[str, str]],
+    metadata: list[tuple[str, str]],
     launcher_puzzle: Program,
-) -> Tuple[bytes32, List[Program], WalletSpendBundle]:
+) -> tuple[bytes32, list[Program], WalletSpendBundle]:
     puzzle_db.add_puzzle(launcher_puzzle)
     launcher_puzzle_hash = launcher_puzzle.get_tree_hash()
     launcher_coin = Coin(parent_coin_id, launcher_puzzle_hash, launcher_amount)
@@ -374,7 +374,7 @@ def p2_singleton_puzzle_hash_for_launcher(
 
 def claim_p2_singleton(
     puzzle_db: PuzzleDB, singleton_wallet: SingletonWallet, p2_singleton_coin: Coin
-) -> Tuple[CoinSpend, List[Program]]:
+) -> tuple[CoinSpend, list[Program]]:
     inner_puzzle = singleton_wallet.inner_puzzle(puzzle_db)
     assert inner_puzzle
     inner_puzzle_hash = inner_puzzle.get_tree_hash()
@@ -432,7 +432,7 @@ def assert_coin_spent(coin_store: CoinStore, coin: Coin, is_spent: bool = True)
 
 def spend_coin_to_singleton(
     puzzle_db: PuzzleDB, launcher_puzzle: Program, coin_store: CoinStore, now: CoinTimestamp
-) -> Tuple[List[Coin], List[CoinSpend]]:
+) -> tuple[list[Coin], list[CoinSpend]]:
     farmed_coin_amount = 100000
     metadata = [("foo", "bar")]
 
@@ -468,7 +468,7 @@ def spend_coin_to_singleton(
     return additions, removals
 
 
-def find_interesting_singletons(removals: List[CoinSpend]) -> List[SingletonWallet]:
+def find_interesting_singletons(removals: list[CoinSpend]) -> list[SingletonWallet]:
     singletons = []
     for coin_spend in removals:
         if coin_spend.coin.puzzle_hash == LAUNCHER_PUZZLE_HASH:
@@ -484,7 +484,7 @@ def find_interesting_singletons(removals: List[CoinSpend]) -> List[SingletonWall
     return singletons
 
 
-def filter_p2_singleton(puzzle_db: PuzzleDB, additions: List[Coin]) -> List[Coin]:
+def filter_p2_singleton(puzzle_db: PuzzleDB, additions: list[Coin]) -> list[Coin]:
     r = []
     for coin in additions:
         puzzle = puzzle_db.puzzle_for_hash(coin.puzzle_hash)
@@ -508,7 +508,7 @@ def test_lifecycle_with_coinstore_as_wallet() -> None:
     now = CoinTimestamp(10012300, uint32(1))
 
     DELAY_SECONDS = 86400
-    DELAY_PUZZLE_HASH = bytes32([0] * 32)
+    DELAY_PUZZLE_HASH = bytes32.zeros
 
     #######
     # spend coin to a singleton

chia/_tests/wallet/test_taproot.py

@@ -8,7 +8,7 @@ from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
 )
 
 
-def test_1():
+def test_1() -> None:
     for main_secret_exponent in range(500, 600):
         hidden_puzzle_hash = DEFAULT_HIDDEN_PUZZLE.get_tree_hash()
         main_pubkey = int_to_public_key(main_secret_exponent)

chia/_tests/wallet/test_transaction_store.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 import random
-from typing import Any, List, Optional, Tuple
+from typing import Any, Optional
 
 import pytest
 
@@ -16,7 +16,11 @@ from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.transaction_record import TransactionRecord, TransactionRecordOld, minimum_send_attempts
 from chia.wallet.util.query_filter import TransactionTypeFilter
 from chia.wallet.util.transaction_type import TransactionType
-from chia.wallet.wallet_transaction_store import WalletTransactionStore, filter_ok_mempool_status
+from chia.wallet.wallet_transaction_store import (
+    WalletTransactionStore,
+    filter_ok_mempool_status,
+    get_light_transaction_record,
+)
 
 module_seeded_random = random.Random()
 module_seeded_random.seed(a=0, version=2)
@@ -37,11 +41,11 @@ tr1 = TransactionRecord(
     [coin_2, coin_3],  # additions
     [coin_1],  # removals
     uint32(1),  # wallet_id
-    [],  # List[Tuple[str, uint8, Optional[str]]] sent_to
+    [],  # list[tuple[str, uint8, Optional[str]]] sent_to
     bytes32(bytes32.random(module_seeded_random)),  # trade_id
     uint32(TransactionType.OUTGOING_TX),  # type
     bytes32(bytes32.random(module_seeded_random)),  # name
-    [],  # List[Tuple[bytes32, List[bytes]]] memos
+    [],  # list[tuple[bytes32, list[bytes]]] memos
     ConditionValidTimes(),
 )
 
@@ -210,7 +214,7 @@ async def test_get_farming_rewards(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
         store = await WalletTransactionStore.create(db_wrapper)
 
-        test_trs: List[TransactionRecord] = []
+        test_trs: list[TransactionRecord] = []
         # tr1 is type OUTGOING_TX
 
         for conf in [True, False]:
@@ -252,8 +256,8 @@ async def test_get_all_unconfirmed(seeded_random: random.Random) -> None:
         )
         await store.add_transaction_record(tr1)
         await store.add_transaction_record(tr2)
-
-        assert await store.get_all_unconfirmed() == [tr1]
+        all_unconfirmed = await store.get_all_unconfirmed()
+        assert all_unconfirmed == [get_light_transaction_record(tr1)]
 
 
 @pytest.mark.anyio
@@ -320,7 +324,7 @@ async def test_all_transactions_for_wallet(seeded_random: random.Random) -> None
     async with DBConnection(1) as db_wrapper:
         store = await WalletTransactionStore.create(db_wrapper)
 
-        test_trs: List[TransactionRecord] = []
+        test_trs: list[TransactionRecord] = []
         for wallet_id in [1, 2]:
             for type in [
                 TransactionType.INCOMING_TX,
@@ -356,7 +360,7 @@ async def test_all_transactions_for_wallet(seeded_random: random.Random) -> None
         assert await store.get_all_transactions_for_wallet(2, TransactionType.OUTGOING_TRADE) == [test_trs[11]]
 
 
-def cmp(lhs: List[Any], rhs: List[Any]) -> bool:
+def cmp(lhs: list[Any], rhs: list[Any]) -> bool:
     if len(rhs) != len(lhs):
         return False
 
@@ -371,7 +375,7 @@ async def test_get_all_transactions(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
         store = await WalletTransactionStore.create(db_wrapper)
 
-        test_trs: List[TransactionRecord] = []
+        test_trs: list[TransactionRecord] = []
         assert await store.get_all_transactions() == []
         for wallet_id in [1, 2, 3, 4]:
             test_trs.append(dataclasses.replace(tr1, name=bytes32.random(seeded_random), wallet_id=uint32(wallet_id)))
@@ -388,7 +392,7 @@ async def test_get_transaction_above(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
         store = await WalletTransactionStore.create(db_wrapper)
 
-        test_trs: List[TransactionRecord] = []
+        test_trs: list[TransactionRecord] = []
         assert await store.get_transaction_above(uint32(0)) == []
         for height in range(10):
             test_trs.append(
@@ -440,7 +444,7 @@ async def test_rollback_to_block(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
         store = await WalletTransactionStore.create(db_wrapper)
 
-        test_trs: List[TransactionRecord] = []
+        test_trs: list[TransactionRecord] = []
         for height in range(10):
             test_trs.append(
                 dataclasses.replace(tr1, name=bytes32.random(seeded_random), confirmed_at_height=uint32(height))
@@ -798,7 +802,7 @@ async def test_get_not_sent(seeded_random: random.Random) -> None:
 
 @pytest.mark.anyio
 async def test_transaction_record_is_valid() -> None:
-    invalid_attempts: List[Tuple[str, uint8, Optional[str]]] = []
+    invalid_attempts: list[tuple[str, uint8, Optional[str]]] = []
     # The tx should be valid as long as we don't have minimum_send_attempts failed attempts
     while len(invalid_attempts) < minimum_send_attempts:
         assert dataclasses.replace(tr1, sent_to=invalid_attempts).is_valid()
@@ -814,9 +818,9 @@ async def test_transaction_record_is_valid() -> None:
         Err.INVALID_FEE_TOO_CLOSE_TO_ZERO.name,
     )
     # But it should become valid with one of the above attempts
-    assert dataclasses.replace(tr1, sent_to=invalid_attempts + [mempool_success]).is_valid()
-    assert dataclasses.replace(tr1, sent_to=invalid_attempts + [low_fee]).is_valid()
-    assert dataclasses.replace(tr1, sent_to=invalid_attempts + [close_to_zero]).is_valid()
+    assert dataclasses.replace(tr1, sent_to=[*invalid_attempts, mempool_success]).is_valid()
+    assert dataclasses.replace(tr1, sent_to=[*invalid_attempts, low_fee]).is_valid()
+    assert dataclasses.replace(tr1, sent_to=[*invalid_attempts, close_to_zero]).is_valid()
 
 
 @pytest.mark.anyio
@@ -842,7 +846,7 @@ async def test_valid_times_migration() -> None:
         old_record = TransactionRecordOld(
             confirmed_at_height=uint32(0),
             created_at_time=uint64(1000000000),
-            to_puzzle_hash=bytes32([0] * 32),
+            to_puzzle_hash=bytes32.zeros,
             amount=uint64(0),
             fee_amount=uint64(0),
             confirmed=False,
@@ -854,7 +858,7 @@ async def test_valid_times_migration() -> None:
             sent_to=[],
             trade_id=None,
             type=uint32(TransactionType.INCOMING_TX.value),
-            name=bytes32([0] * 32),
+            name=bytes32.zeros,
             memos=[],
         )
 
@@ -893,7 +897,7 @@ async def test_large_tx_record_query() -> None:
             record = TransactionRecordOld(
                 confirmed_at_height=uint32(0),
                 created_at_time=uint64(1000000000),
-                to_puzzle_hash=bytes32([0] * 32),
+                to_puzzle_hash=bytes32.zeros,
                 amount=uint64(0),
                 fee_amount=uint64(0),
                 confirmed=False,

chia/_tests/wallet/test_util.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Tuple
+from typing import Any
 
 import pytest
 
@@ -21,6 +21,7 @@ from chia.wallet.util.tx_config import (
     CoinSelectionConfigLoader,
     TXConfigLoader,
 )
+from chia.wallet.util.wallet_types import WalletType
 
 
 def test_compute_spend_hints_and_additions() -> None:
@@ -36,22 +37,18 @@ def test_compute_spend_hints_and_additions() -> None:
     expected_dict = {hinted_coin.coin.name(): hinted_coin for hinted_coin in hinted_coins}
     assert compute_spend_hints_and_additions(coin_spend)[0] == expected_dict
 
-    not_hinted_coin = HintedCoin(Coin(parent_coin.coin.name(), bytes32([0] * 32), uint64(0)), None)
+    not_hinted_coin = HintedCoin(Coin(parent_coin.coin.name(), bytes32.zeros, uint64(0)), None)
     assert compute_spend_hints_and_additions(
-        make_spend(parent_coin.coin, Program.to(1), Program.to([[51, bytes32([0] * 32), 0, [["not", "a"], "hint"]]]))
+        make_spend(parent_coin.coin, Program.to(1), Program.to([[51, bytes32.zeros, 0, [["not", "a"], "hint"]]]))
     )[0] == {not_hinted_coin.coin.name(): not_hinted_coin}
 
     with pytest.raises(ValidationError):
         compute_spend_hints_and_additions(
-            make_spend(
-                parent_coin.coin, Program.to(1), Program.to([[51, bytes32([0] * 32), 0] for _ in range(0, 10000)])
-            )
+            make_spend(parent_coin.coin, Program.to(1), Program.to([[51, bytes32.zeros, 0] for _ in range(0, 10000)]))
         )
     with pytest.raises(ValidationError):
         compute_spend_hints_and_additions(
-            make_spend(
-                parent_coin.coin, Program.to(1), Program.to([[50, bytes48([0] * 48), b""] for _ in range(0, 10000)])
-            )
+            make_spend(parent_coin.coin, Program.to(1), Program.to([[50, bytes48.zeros, b""] for _ in range(0, 10000)]))
         )
 
 
@@ -66,7 +63,7 @@ def test_cs_config() -> None:
         "min_coin_amount": 50,
     }
     coin_to_exclude = CoinGenerator().get().coin
-    coin_id_to_exclude = bytes32([0] * 32)
+    coin_id_to_exclude = bytes32.zeros
     assert CoinSelectionConfigLoader.from_json_dict(
         {
             "excluded_coins": [coin_to_exclude.to_json_dict()],
@@ -80,9 +77,7 @@ def test_cs_config() -> None:
         {
             "excluded_coins": [coin_to_exclude.to_json_dict()],
         }
-    ).override(
-        max_coin_amount=100
-    ).autofill(constants=DEFAULT_CONSTANTS).to_json_dict() == {
+    ).override(max_coin_amount=100).autofill(constants=DEFAULT_CONSTANTS).to_json_dict() == {
         **default_cs_config,
         "excluded_coin_ids": ["0x" + coin_to_exclude.name().hex()],
         "max_coin_amount": 100,
@@ -112,20 +107,20 @@ def test_list_to_binary_tree() -> None:
     "serializations",
     [
         (tuple(), Program.to(None), []),
-        ((bytes32([0] * 32),), Program.to([bytes32([0] * 32)]), [LineageProofField.PARENT_NAME]),
+        ((bytes32.zeros,), Program.to([bytes32.zeros]), [LineageProofField.PARENT_NAME]),
         (
-            (bytes32([0] * 32), bytes32([0] * 32)),
-            Program.to([bytes32([0] * 32), bytes32([0] * 32)]),
+            (bytes32.zeros, bytes32.zeros),
+            Program.to([bytes32.zeros, bytes32.zeros]),
             [LineageProofField.PARENT_NAME, LineageProofField.INNER_PUZZLE_HASH],
         ),
         (
-            (bytes32([0] * 32), bytes32([0] * 32), uint64(0)),
-            Program.to([bytes32([0] * 32), bytes32([0] * 32), uint64(0)]),
+            (bytes32.zeros, bytes32.zeros, uint64(0)),
+            Program.to([bytes32.zeros, bytes32.zeros, uint64(0)]),
             [LineageProofField.PARENT_NAME, LineageProofField.INNER_PUZZLE_HASH, LineageProofField.AMOUNT],
         ),
     ],
 )
-def test_lineage_proof_varargs(serializations: Tuple[Tuple[Any, ...], Program, List[LineageProofField]]) -> None:
+def test_lineage_proof_varargs(serializations: tuple[tuple[Any, ...], Program, list[LineageProofField]]) -> None:
     var_args, expected_program, lp_fields = serializations
     assert LineageProof(*var_args).to_program() == expected_program
     assert LineageProof(*var_args) == LineageProof.from_program(expected_program, lp_fields)
@@ -135,36 +130,36 @@ def test_lineage_proof_varargs(serializations: Tuple[Tuple[Any, ...], Program, L
     "serializations",
     [
         ({}, Program.to(None), []),
-        ({"parent_name": bytes32([0] * 32)}, Program.to([bytes32([0] * 32)]), [LineageProofField.PARENT_NAME]),
+        ({"parent_name": bytes32.zeros}, Program.to([bytes32.zeros]), [LineageProofField.PARENT_NAME]),
         (
-            {"parent_name": bytes32([0] * 32), "inner_puzzle_hash": bytes32([0] * 32)},
-            Program.to([bytes32([0] * 32), bytes32([0] * 32)]),
+            {"parent_name": bytes32.zeros, "inner_puzzle_hash": bytes32.zeros},
+            Program.to([bytes32.zeros, bytes32.zeros]),
             [LineageProofField.PARENT_NAME, LineageProofField.INNER_PUZZLE_HASH],
         ),
         (
-            {"parent_name": bytes32([0] * 32), "inner_puzzle_hash": bytes32([0] * 32), "amount": uint64(0)},
-            Program.to([bytes32([0] * 32), bytes32([0] * 32), uint64(0)]),
+            {"parent_name": bytes32.zeros, "inner_puzzle_hash": bytes32.zeros, "amount": uint64(0)},
+            Program.to([bytes32.zeros, bytes32.zeros, uint64(0)]),
             [LineageProofField.PARENT_NAME, LineageProofField.INNER_PUZZLE_HASH, LineageProofField.AMOUNT],
         ),
         (
-            {"parent_name": bytes32([0] * 32), "amount": uint64(0)},
-            Program.to([bytes32([0] * 32), uint64(0)]),
+            {"parent_name": bytes32.zeros, "amount": uint64(0)},
+            Program.to([bytes32.zeros, uint64(0)]),
             [LineageProofField.PARENT_NAME, LineageProofField.AMOUNT],
         ),
         (
-            {"inner_puzzle_hash": bytes32([0] * 32), "amount": uint64(0)},
-            Program.to([bytes32([0] * 32), uint64(0)]),
+            {"inner_puzzle_hash": bytes32.zeros, "amount": uint64(0)},
+            Program.to([bytes32.zeros, uint64(0)]),
             [LineageProofField.INNER_PUZZLE_HASH, LineageProofField.AMOUNT],
         ),
         ({"amount": uint64(0)}, Program.to([uint64(0)]), [LineageProofField.AMOUNT]),
         (
-            {"inner_puzzle_hash": bytes32([0] * 32)},
-            Program.to([bytes32([0] * 32)]),
+            {"inner_puzzle_hash": bytes32.zeros},
+            Program.to([bytes32.zeros]),
             [LineageProofField.INNER_PUZZLE_HASH],
         ),
     ],
 )
-def test_lineage_proof_kwargs(serializations: Tuple[Dict[str, Any], Program, List[LineageProofField]]) -> None:
+def test_lineage_proof_kwargs(serializations: tuple[dict[str, Any], Program, list[LineageProofField]]) -> None:
     kwargs, expected_program, lp_fields = serializations
     assert LineageProof(**kwargs).to_program() == expected_program
     assert LineageProof(**kwargs) == LineageProof.from_program(expected_program, lp_fields)
@@ -174,8 +169,17 @@ def test_lineage_proof_errors() -> None:
     with pytest.raises(ValueError, match="Mismatch"):
         LineageProof.from_program(Program.to([]), [LineageProofField.PARENT_NAME])
     with pytest.raises(StopIteration):
-        LineageProof.from_program(Program.to([bytes32([0] * 32)]), [])
+        LineageProof.from_program(Program.to([bytes32.zeros]), [])
     with pytest.raises(ValueError):
         LineageProof.from_program(Program.to([bytes32([1] * 32)]), [LineageProofField.AMOUNT])
     with pytest.raises(ValueError):
         LineageProof.from_program(Program.to([uint64(0)]), [LineageProofField.PARENT_NAME])
+
+
+# this is the only test that has coverage for `WalletType.to_json_dict`
+# it's possible it could even be deleted
+
+
+def test_wallet_type_to_json() -> None:
+    for w in WalletType:
+        assert w.to_json_dict() == w.name