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

chia/_tests/wallet/test_wallet.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import pytest
 from chia_rs import AugSchemeMPL, G1Element, G2Element
@@ -78,7 +78,7 @@ class TestWalletSimulator:
         async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
             await wallet.generate_signed_transaction(
                 uint64(tx_amount),
-                bytes32([0] * 32),
+                bytes32.zeros,
                 action_scope,
                 uint64(0),
             )
@@ -112,7 +112,7 @@ class TestWalletSimulator:
         async with wallet.wallet_state_manager.new_action_scope(
             wallet_environments.tx_config, push=False
         ) as action_scope:
-            selected_coin = list(await wallet.select_coins(uint64(0), action_scope))[0]
+            selected_coin = next(iter(await wallet.select_coins(uint64(0), action_scope)))
         assert await wallet.match_hinted_coin(selected_coin, selected_coin.puzzle_hash)
 
     @pytest.mark.parametrize(
@@ -133,7 +133,7 @@ class TestWalletSimulator:
         ) as action_scope:
             await wallet.generate_signed_transaction(
                 uint64(tx_amount),
-                bytes32([0] * 32),
+                bytes32.zeros,
                 action_scope,
                 uint64(0),
             )
@@ -577,7 +577,7 @@ class TestWalletSimulator:
         assert txs["transactions"][0]["confirmed"]
         assert txs["transactions"][1]["confirmed"]
         assert txs["transactions"][0]["memos"] != txs["transactions"][1]["memos"]
-        assert list(txs["transactions"][0]["memos"].values())[0] == b"Test".hex()
+        assert next(iter(txs["transactions"][0]["memos"].values())) == b"Test".hex()
 
     @pytest.mark.parametrize(
         "wallet_environments",
@@ -777,7 +777,7 @@ class TestWalletSimulator:
         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 - 2), uint32(height + 1), bytes32([0] * 32), None)
+            ReorgProtocol(uint32(height - 2), uint32(height + 1), bytes32.zeros, None)
         )
 
         await time_out_assert(20, wsm.coin_store.count_small_unspent, 0, 1000, CoinType.CLAWBACK)
@@ -859,7 +859,7 @@ class TestWalletSimulator:
         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 time_out_assert(20, wsm.coin_store.count_small_unspent, 1, 1000, CoinType.CLAWBACK)
@@ -916,7 +916,7 @@ class TestWalletSimulator:
         async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
             await wallet.generate_signed_transaction(
                 uint64(tx_amount),
-                bytes32([0] * 32),
+                bytes32.zeros,
                 action_scope,
                 uint64(0),
                 puzzle_decorator_override=[{"decorator": "CLAWBACK", "clawback_timelock": 500}],
@@ -1112,11 +1112,11 @@ class TestWalletSimulator:
         await time_out_assert(20, wsm_1.coin_store.count_small_unspent, 0, 1000, CoinType.CLAWBACK)
         await time_out_assert(20, wsm_2.coin_store.count_small_unspent, 0, 1000, CoinType.CLAWBACK)
 
-        before_txs: Dict[str, Dict[TransactionType, int]] = {"sender": {}, "recipient": {}}
-        before_txs["sender"][TransactionType.INCOMING_CLAWBACK_SEND] = (
-            await wsm_1.tx_store.get_transaction_count_for_wallet(
-                1, type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_SEND])
-            )
+        before_txs: dict[str, dict[TransactionType, int]] = {"sender": {}, "recipient": {}}
+        before_txs["sender"][
+            TransactionType.INCOMING_CLAWBACK_SEND
+        ] = await wsm_1.tx_store.get_transaction_count_for_wallet(
+            1, type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_SEND])
         )
         before_txs["sender"][TransactionType.OUTGOING_CLAWBACK] = await wsm_1.tx_store.get_transaction_count_for_wallet(
             1, type_filter=TransactionTypeFilter.include([TransactionType.OUTGOING_CLAWBACK])
@@ -1130,10 +1130,10 @@ class TestWalletSimulator:
         before_txs["sender"][TransactionType.COINBASE_REWARD] = await wsm_1.tx_store.get_transaction_count_for_wallet(
             1, type_filter=TransactionTypeFilter.include([TransactionType.COINBASE_REWARD])
         )
-        before_txs["recipient"][TransactionType.INCOMING_CLAWBACK_RECEIVE] = (
-            await wsm_2.tx_store.get_transaction_count_for_wallet(
-                1, type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_RECEIVE])
-            )
+        before_txs["recipient"][
+            TransactionType.INCOMING_CLAWBACK_RECEIVE
+        ] = await wsm_2.tx_store.get_transaction_count_for_wallet(
+            1, type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_RECEIVE])
         )
         # Resync start
         env_1.node._close()
@@ -1159,11 +1159,11 @@ class TestWalletSimulator:
         wsm_1 = env_1.node.wallet_state_manager
         wsm_2 = env_2.node.wallet_state_manager
 
-        after_txs: Dict[str, Dict[TransactionType, int]] = {"sender": {}, "recipient": {}}
-        after_txs["sender"][TransactionType.INCOMING_CLAWBACK_SEND] = (
-            await wsm_1.tx_store.get_transaction_count_for_wallet(
-                1, type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_SEND])
-            )
+        after_txs: dict[str, dict[TransactionType, int]] = {"sender": {}, "recipient": {}}
+        after_txs["sender"][
+            TransactionType.INCOMING_CLAWBACK_SEND
+        ] = await wsm_1.tx_store.get_transaction_count_for_wallet(
+            1, type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_SEND])
         )
         after_txs["sender"][TransactionType.OUTGOING_CLAWBACK] = await wsm_1.tx_store.get_transaction_count_for_wallet(
             1, type_filter=TransactionTypeFilter.include([TransactionType.OUTGOING_CLAWBACK])
@@ -1177,10 +1177,10 @@ class TestWalletSimulator:
         after_txs["sender"][TransactionType.COINBASE_REWARD] = await wsm_1.tx_store.get_transaction_count_for_wallet(
             1, type_filter=TransactionTypeFilter.include([TransactionType.COINBASE_REWARD])
         )
-        after_txs["recipient"][TransactionType.INCOMING_CLAWBACK_RECEIVE] = (
-            await wsm_2.tx_store.get_transaction_count_for_wallet(
-                1, type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_RECEIVE])
-            )
+        after_txs["recipient"][
+            TransactionType.INCOMING_CLAWBACK_RECEIVE
+        ] = await wsm_2.tx_store.get_transaction_count_for_wallet(
+            1, type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_RECEIVE])
         )
         # Check clawback
         clawback_tx_1 = await wsm_1.tx_store.get_transaction_record(clawback_coin_id_1)
@@ -1260,7 +1260,7 @@ class TestWalletSimulator:
     @pytest.mark.anyio
     async def test_wallet_send_to_three_peers(
         self,
-        three_sim_two_wallets: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+        three_sim_two_wallets: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
         trusted: bool,
         self_hostname: str,
     ) -> None:
@@ -1666,7 +1666,7 @@ class TestWalletSimulator:
         async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
             await wallet.generate_signed_transaction(
                 uint64(tx_amount),
-                bytes32([0] * 32),
+                bytes32.zeros,
                 action_scope,
                 uint64(tx_fee),
             )
@@ -2042,7 +2042,7 @@ class TestWalletSimulator:
             coin_list = list(coins)
             await wallet.generate_signed_transaction(
                 uint64(AMOUNT_TO_SEND),
-                bytes32([0] * 32),
+                bytes32.zeros,
                 action_scope,
                 uint64(0),
                 coins=coins,
@@ -2050,7 +2050,7 @@ class TestWalletSimulator:
             )
         [tx] = action_scope.side_effects.transactions
         assert tx.spend_bundle is not None
-        paid_coin = [coin for coin in tx.spend_bundle.additions() if coin.amount == AMOUNT_TO_SEND][0]
+        paid_coin = next(coin for coin in tx.spend_bundle.additions() if coin.amount == AMOUNT_TO_SEND)
         assert paid_coin.parent_coin_info == coin_list[2].name()
         [tx] = await wallet.wallet_state_manager.add_pending_transactions([tx])
 
@@ -2083,7 +2083,7 @@ class TestWalletSimulator:
 
 def test_get_wallet_db_path_v2_r1() -> None:
     root_path: Path = Path("/x/y/z/.chia/mainnet").resolve()
-    config: Dict[str, Any] = {
+    config: dict[str, Any] = {
         "database_path": "wallet/db/blockchain_wallet_v2_r1_CHALLENGE_KEY.sqlite",
         "selected_network": "mainnet",
     }
@@ -2095,7 +2095,7 @@ def test_get_wallet_db_path_v2_r1() -> None:
 
 def test_get_wallet_db_path_v2() -> None:
     root_path: Path = Path("/x/y/z/.chia/mainnet").resolve()
-    config: Dict[str, Any] = {
+    config: dict[str, Any] = {
         "database_path": "wallet/db/blockchain_wallet_v2_CHALLENGE_KEY.sqlite",
         "selected_network": "mainnet",
     }
@@ -2107,7 +2107,7 @@ def test_get_wallet_db_path_v2() -> None:
 
 def test_get_wallet_db_path_v1() -> None:
     root_path: Path = Path("/x/y/z/.chia/mainnet").resolve()
-    config: Dict[str, Any] = {
+    config: dict[str, Any] = {
         "database_path": "wallet/db/blockchain_wallet_v1_CHALLENGE_KEY.sqlite",
         "selected_network": "mainnet",
     }
@@ -2119,7 +2119,7 @@ def test_get_wallet_db_path_v1() -> None:
 
 def test_get_wallet_db_path_testnet() -> None:
     root_path: Path = Path("/x/y/z/.chia/testnet").resolve()
-    config: Dict[str, Any] = {
+    config: dict[str, Any] = {
         "database_path": "wallet/db/blockchain_wallet_v2_CHALLENGE_KEY.sqlite",
         "selected_network": "testnet",
     }
@@ -2131,9 +2131,9 @@ def test_get_wallet_db_path_testnet() -> None:
 
 @pytest.mark.anyio
 async def test_wallet_has_no_server(
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
 ) -> None:
-    full_nodes, wallets, bt = simulator_and_wallet
-    wallet_node, wallet_server = wallets[0]
+    _full_nodes, wallets, _bt = simulator_and_wallet
+    _wallet_node, wallet_server = wallets[0]
 
     assert wallet_server.webserver is None

chia/_tests/wallet/test_wallet_action_scope.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List, Optional, Tuple
+from typing import Optional
 
 import pytest
 from chia_rs import G2Element
@@ -17,9 +17,9 @@ from chia.wallet.wallet_action_scope import WalletSideEffects
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 from chia.wallet.wallet_state_manager import WalletStateManager
 
-MOCK_SR = SigningResponse(b"hey", bytes32([0] * 32))
+MOCK_SR = SigningResponse(b"hey", bytes32.zeros)
 MOCK_SB = WalletSpendBundle([], G2Element())
-MOCK_COIN = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(0))
+MOCK_COIN = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
 
 
 def test_back_and_forth_serialization() -> None:
@@ -36,18 +36,18 @@ def test_back_and_forth_serialization() -> None:
 @dataclass
 class MockWalletStateManager:
     most_recent_call: Optional[
-        Tuple[List[TransactionRecord], bool, bool, bool, List[SigningResponse], List[WalletSpendBundle]]
+        tuple[list[TransactionRecord], bool, bool, bool, list[SigningResponse], list[WalletSpendBundle]]
     ] = None
 
     async def add_pending_transactions(
         self,
-        txs: List[TransactionRecord],
+        txs: list[TransactionRecord],
         push: bool,
         merge_spends: bool,
         sign: bool,
-        additional_signing_responses: List[SigningResponse],
-        extra_spends: List[WalletSpendBundle],
-    ) -> List[TransactionRecord]:
+        additional_signing_responses: list[SigningResponse],
+        extra_spends: list[WalletSpendBundle],
+    ) -> list[TransactionRecord]:
         self.most_recent_call = (txs, push, merge_spends, sign, additional_signing_responses, extra_spends)
         return txs
 

chia/_tests/wallet/test_wallet_blockchain.py

@@ -1,14 +1,12 @@
 from __future__ import annotations
 
-from typing import List
-
 import pytest
 
 from chia._tests.util.db_connection import DBConnection
-from chia._tests.util.misc import add_blocks_in_batches
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
 from chia.consensus.blockchain import AddBlockResult
 from chia.protocols import full_node_protocol
+from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.types.blockchain_format.vdf import VDFProof
 from chia.types.full_block import FullBlock
 from chia.types.header_block import HeaderBlock
@@ -21,7 +19,7 @@ from chia.wallet.wallet_blockchain import WalletBlockchain
 @pytest.mark.anyio
 @pytest.mark.standard_block_tools
 async def test_wallet_blockchain(
-    simulator_and_wallet: OldSimulatorsAndWallets, default_1000_blocks: List[FullBlock]
+    simulator_and_wallet: OldSimulatorsAndWallets, default_1000_blocks: list[FullBlock]
 ) -> None:
     [full_node_api], [(wallet_node, _)], bt = simulator_and_wallet
 
@@ -75,9 +73,9 @@ async def test_wallet_blockchain(
         assert peak_block is not None
         assert peak_block.height == 505
 
-        header_blocks: List[HeaderBlock] = []
+        header_blocks: list[HeaderBlock] = []
         for block in default_1000_blocks:
-            header_block = get_block_header(block, [], [])
+            header_block = get_block_header(block)
             header_blocks.append(header_block)
 
         res, err = await chain.add_block(header_blocks[50])

chia/_tests/wallet/test_wallet_coin_store.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import random
 from dataclasses import dataclass, field, replace
-from typing import Dict, List, Optional, Tuple
+from typing import Optional
 
 import pytest
 
@@ -118,7 +118,7 @@ def get_dummy_record(wallet_id: int, seeded_random: random.Random) -> WalletCoin
 @dataclass
 class DummyWalletCoinRecords:
     seeded_random: random.Random
-    records_per_wallet: Dict[int, List[WalletCoinRecord]] = field(default_factory=dict)
+    records_per_wallet: dict[int, list[WalletCoinRecord]] = field(default_factory=dict)
 
     def generate(self, wallet_id: int, count: int) -> None:
         records = self.records_per_wallet.setdefault(wallet_id, [])
@@ -367,7 +367,7 @@ async def test_delete_coin_record() -> None:
         ).records == [record_2, record_3, record_4, record_5, record_6, record_7]
 
 
-get_coin_records_offset_limit_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_offset_limit_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (GetCoinRecords(offset=uint32(0), limit=uint32(0)), []),
     (GetCoinRecords(offset=uint32(10), limit=uint32(0)), []),
     (GetCoinRecords(offset=uint32(0), limit=uint32(1)), [record_8]),
@@ -379,7 +379,7 @@ get_coin_records_offset_limit_tests: List[Tuple[GetCoinRecords, List[WalletCoinR
     (GetCoinRecords(coin_type=uint8(CoinType.CLAWBACK), offset=uint32(5), limit=uint32(1)), []),
 ]
 
-get_coin_records_wallet_id_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_wallet_id_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (
         GetCoinRecords(),
         [record_8, record_9, record_1, record_2, record_3, record_4, record_5, record_6, record_7],
@@ -389,13 +389,13 @@ get_coin_records_wallet_id_tests: List[Tuple[GetCoinRecords, List[WalletCoinReco
     (GetCoinRecords(wallet_id=uint32(2)), [record_9, record_6, record_7]),
 ]
 
-get_coin_records_wallet_type_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_wallet_type_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (GetCoinRecords(wallet_id=uint32(2), wallet_type=uint8(WalletType.STANDARD_WALLET)), [record_9, record_6]),
     (GetCoinRecords(wallet_type=uint8(WalletType.POOLING_WALLET)), [record_7]),
     (GetCoinRecords(wallet_type=uint8(WalletType.NFT)), []),
 ]
 
-get_coin_records_coin_type_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_coin_type_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (GetCoinRecords(wallet_id=uint32(0), coin_type=uint8(CoinType.NORMAL)), [record_1, record_2, record_3, record_4]),
     (GetCoinRecords(wallet_id=uint32(0), coin_type=uint8(CoinType.CLAWBACK)), []),
     (GetCoinRecords(wallet_id=uint32(1), coin_type=uint8(CoinType.NORMAL)), [record_5]),
@@ -403,7 +403,7 @@ get_coin_records_coin_type_tests: List[Tuple[GetCoinRecords, List[WalletCoinReco
     (GetCoinRecords(coin_type=uint8(CoinType.CLAWBACK)), [record_8, record_9]),
 ]
 
-get_coin_records_coin_id_filter_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_coin_id_filter_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (GetCoinRecords(coin_id_filter=HashFilter.include([])), []),
     (GetCoinRecords(coin_id_filter=HashFilter.include([coin_1.name(), coin_4.name()])), [record_1, record_4]),
     (GetCoinRecords(coin_id_filter=HashFilter.include([coin_1.name(), coin_4.puzzle_hash])), [record_1]),
@@ -416,7 +416,7 @@ get_coin_records_coin_id_filter_tests: List[Tuple[GetCoinRecords, List[WalletCoi
 ]
 
 
-get_coin_records_puzzle_hash_filter_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_puzzle_hash_filter_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (GetCoinRecords(puzzle_hash_filter=HashFilter.include([])), []),
     (
         GetCoinRecords(puzzle_hash_filter=HashFilter.include([coin_1.puzzle_hash, coin_4.puzzle_hash])),
@@ -439,7 +439,7 @@ get_coin_records_puzzle_hash_filter_tests: List[Tuple[GetCoinRecords, List[Walle
     ),
 ]
 
-get_coin_records_parent_coin_id_filter_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_parent_coin_id_filter_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (GetCoinRecords(parent_coin_id_filter=HashFilter.include([])), []),
     (
         GetCoinRecords(parent_coin_id_filter=HashFilter.include([coin_5.name(), coin_4.parent_coin_info])),
@@ -463,7 +463,7 @@ get_coin_records_parent_coin_id_filter_tests: List[Tuple[GetCoinRecords, List[Wa
     ),
 ]
 
-get_coin_records_amount_filter_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_amount_filter_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (GetCoinRecords(amount_filter=AmountFilter.include([])), []),
     (
         GetCoinRecords(amount_filter=AmountFilter.include([uint64(12312)])),
@@ -491,7 +491,7 @@ get_coin_records_amount_filter_tests: List[Tuple[GetCoinRecords, List[WalletCoin
     ),
 ]
 
-get_coin_records_amount_range_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_amount_range_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (GetCoinRecords(amount_range=UInt64Range(start=uint64(1000000))), []),
     (GetCoinRecords(amount_range=UInt64Range(stop=uint64(0))), []),
     (
@@ -504,7 +504,7 @@ get_coin_records_amount_range_tests: List[Tuple[GetCoinRecords, List[WalletCoinR
     (GetCoinRecords(amount_range=UInt64Range(start=uint64(5), stop=uint64(12311))), [record_2]),
 ]
 
-get_coin_records_confirmed_range_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_confirmed_range_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (GetCoinRecords(confirmed_range=UInt32Range(start=uint32(20))), []),
     (GetCoinRecords(confirmed_range=UInt32Range(stop=uint32(0))), []),
     (GetCoinRecords(confirmed_range=UInt32Range(start=uint32(2), stop=uint32(1))), []),
@@ -521,7 +521,7 @@ get_coin_records_confirmed_range_tests: List[Tuple[GetCoinRecords, List[WalletCo
     ),
 ]
 
-get_coin_records_spent_range_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_spent_range_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (GetCoinRecords(spent_range=UInt32Range(start=uint32(20))), []),
     (GetCoinRecords(spent_range=UInt32Range(stop=uint32(0))), [record_8, record_1, record_2, record_5, record_7]),
     (GetCoinRecords(spent_range=UInt32Range(start=uint32(2), stop=uint32(1))), []),
@@ -530,7 +530,7 @@ get_coin_records_spent_range_tests: List[Tuple[GetCoinRecords, List[WalletCoinRe
     (GetCoinRecords(spent_range=UInt32Range(start=uint32(5), stop=uint32(15))), [record_3, record_4, record_6]),
 ]
 
-get_coin_records_order_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_order_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (
         GetCoinRecords(wallet_id=uint32(0), order=uint8(CoinRecordOrder.spent_height)),
         [record_1, record_2, record_3, record_4],
@@ -544,7 +544,7 @@ get_coin_records_order_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]
     ),
 ]
 
-get_coin_records_reverse_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord]]] = [
+get_coin_records_reverse_tests: list[tuple[GetCoinRecords, list[WalletCoinRecord]]] = [
     (
         GetCoinRecords(wallet_id=uint32(0), order=uint8(CoinRecordOrder.spent_height), reverse=True),
         [record_4, record_3, record_1, record_2],
@@ -567,7 +567,7 @@ get_coin_records_reverse_tests: List[Tuple[GetCoinRecords, List[WalletCoinRecord
     ),
 ]
 
-get_coin_records_include_total_count_tests: List[Tuple[GetCoinRecords, int, List[WalletCoinRecord]]] = [
+get_coin_records_include_total_count_tests: list[tuple[GetCoinRecords, int, list[WalletCoinRecord]]] = [
     (GetCoinRecords(wallet_id=uint32(0), include_total_count=True), 4, [record_1, record_2, record_3, record_4]),
     (
         GetCoinRecords(wallet_id=uint32(0), offset=uint32(1), limit=uint32(2), include_total_count=True),
@@ -579,7 +579,7 @@ get_coin_records_include_total_count_tests: List[Tuple[GetCoinRecords, int, List
     (GetCoinRecords(wallet_type=uint8(WalletType.POOLING_WALLET), include_total_count=True), 1, [record_7]),
 ]
 
-get_coin_records_mixed_tests: List[Tuple[GetCoinRecords, int, List[WalletCoinRecord]]] = [
+get_coin_records_mixed_tests: list[tuple[GetCoinRecords, int, list[WalletCoinRecord]]] = [
     (
         GetCoinRecords(
             offset=uint32(2),
@@ -632,7 +632,7 @@ get_coin_records_mixed_tests: List[Tuple[GetCoinRecords, int, List[WalletCoinRec
 
 
 async def run_get_coin_records_test(
-    request: GetCoinRecords, total_count: Optional[int], coin_records: List[WalletCoinRecord]
+    request: GetCoinRecords, total_count: Optional[int], coin_records: list[WalletCoinRecord]
 ) -> None:
     async with DBConnection(1) as db_wrapper:
         store = await WalletCoinStore.create(db_wrapper)
@@ -665,38 +665,38 @@ async def run_get_coin_records_test(
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_offset_limit_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_offset_limit(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_offset_limit(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_wallet_id_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_wallet_id(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_wallet_id(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_wallet_type_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_wallet_type(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_wallet_type(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_coin_type_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_coin_type(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_coin_type(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_coin_id_filter_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_coin_id_filter(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_coin_id_filter(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_puzzle_hash_filter_tests])
 @pytest.mark.anyio
 async def test_get_coin_records_puzzle_hash_filter(
-    coins_request: GetCoinRecords, records: List[WalletCoinRecord]
+    coins_request: GetCoinRecords, records: list[WalletCoinRecord]
 ) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
@@ -704,51 +704,51 @@ async def test_get_coin_records_puzzle_hash_filter(
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_parent_coin_id_filter_tests])
 @pytest.mark.anyio
 async def test_get_coin_records_parent_coin_id_filter(
-    coins_request: GetCoinRecords, records: List[WalletCoinRecord]
+    coins_request: GetCoinRecords, records: list[WalletCoinRecord]
 ) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_amount_filter_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_amount_filter(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_amount_filter(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_confirmed_range_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_confirmed_range(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_confirmed_range(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_spent_range_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_spent_range(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_spent_range(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_amount_range_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_amount_range(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_amount_range(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_order_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_order(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_order(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, records", [*get_coin_records_reverse_tests])
 @pytest.mark.anyio
-async def test_get_coin_records_reverse(coins_request: GetCoinRecords, records: List[WalletCoinRecord]) -> None:
+async def test_get_coin_records_reverse(coins_request: GetCoinRecords, records: list[WalletCoinRecord]) -> None:
     await run_get_coin_records_test(coins_request, None, records)
 
 
 @pytest.mark.parametrize("coins_request, total_count, records", [*get_coin_records_include_total_count_tests])
 @pytest.mark.anyio
 async def test_get_coin_records_total_count(
-    coins_request: GetCoinRecords, total_count: int, records: List[WalletCoinRecord]
+    coins_request: GetCoinRecords, total_count: int, records: list[WalletCoinRecord]
 ) -> None:
     await run_get_coin_records_test(coins_request, total_count, records)
 
@@ -756,7 +756,7 @@ async def test_get_coin_records_total_count(
 @pytest.mark.parametrize("coins_request, total_count, records", [*get_coin_records_mixed_tests])
 @pytest.mark.anyio
 async def test_get_coin_records_mixed(
-    coins_request: GetCoinRecords, total_count: int, records: List[WalletCoinRecord]
+    coins_request: GetCoinRecords, total_count: int, records: list[WalletCoinRecord]
 ) -> None:
     await run_get_coin_records_test(coins_request, total_count, records)
 
@@ -787,7 +787,7 @@ async def test_get_coin_records_total_count_cache() -> None:
         assert (await store.get_coin_records(include_total_count=True)).total_count == 3
         # Make sure the total count increases for the same query when rolling back
         assert (await store.get_coin_records(include_total_count=True)).total_count == 3
-        await store.rollback_to_block(0),
+        await store.rollback_to_block(0)
         assert (await store.get_coin_records(include_total_count=True)).total_count == 0