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

chia/full_node/block_store.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import dataclasses
 import logging
 import sqlite3
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Optional
 
 import typing_extensions
 import zstd
@@ -40,7 +40,7 @@ def decompress_blob(block_bytes: bytes) -> bytes:
 class BlockStore:
     block_cache: LRUCache[bytes32, FullBlock]
     db_wrapper: DBWrapper2
-    ses_challenge_cache: LRUCache[bytes32, List[SubEpochChallengeSegment]]
+    ses_challenge_cache: LRUCache[bytes32, list[SubEpochChallengeSegment]]
 
     @classmethod
     async def create(cls, db_wrapper: DBWrapper2, *, use_cache: bool = True) -> BlockStore:
@@ -105,7 +105,7 @@ class BlockStore:
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             await conn.execute("UPDATE full_blocks SET in_main_chain=0 WHERE height>? AND in_main_chain=1", (height,))
 
-    async def set_in_chain(self, header_hashes: List[Tuple[bytes32]]) -> None:
+    async def set_in_chain(self, header_hashes: list[tuple[bytes32]]) -> None:
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             async with await conn.executemany(
                 "UPDATE full_blocks SET in_main_chain=1 WHERE header_hash=?", header_hashes
@@ -162,7 +162,7 @@ class BlockStore:
             )
 
     async def persist_sub_epoch_challenge_segments(
-        self, ses_block_hash: bytes32, segments: List[SubEpochChallengeSegment]
+        self, ses_block_hash: bytes32, segments: list[SubEpochChallengeSegment]
     ) -> None:
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             await conn.execute(
@@ -173,8 +173,8 @@ class BlockStore:
     async def get_sub_epoch_challenge_segments(
         self,
         ses_block_hash: bytes32,
-    ) -> Optional[List[SubEpochChallengeSegment]]:
-        cached: Optional[List[SubEpochChallengeSegment]] = self.ses_challenge_cache.get(ses_block_hash)
+    ) -> Optional[list[SubEpochChallengeSegment]]:
+        cached: Optional[list[SubEpochChallengeSegment]] = self.ses_challenge_cache.get(ses_block_hash)
         if cached is not None:
             return cached
 
@@ -186,7 +186,7 @@ class BlockStore:
                 row = await cursor.fetchone()
 
         if row is not None:
-            challenge_segments: List[SubEpochChallengeSegment] = SubEpochSegments.from_bytes(row[0]).challenge_segments
+            challenge_segments: list[SubEpochChallengeSegment] = SubEpochSegments.from_bytes(row[0]).challenge_segments
             self.ses_challenge_cache.put(ses_block_hash, challenge_segments)
             return challenge_segments
         return None
@@ -225,14 +225,17 @@ class BlockStore:
 
         return None
 
-    async def get_full_blocks_at(self, heights: List[uint32]) -> List[FullBlock]:
+    async def get_full_blocks_at(self, heights: list[uint32]) -> list[FullBlock]:
+        """
+        Returns all blocks at the given heights, including orphans.
+        """
         if len(heights) == 0:
             return []
 
         formatted_str = f'SELECT block from full_blocks WHERE height in ({"?," * (len(heights) - 1)}?)'
         async with self.db_wrapper.reader_no_transaction() as conn:
             async with conn.execute(formatted_str, heights) as cursor:
-                ret: List[FullBlock] = []
+                ret: list[FullBlock] = []
                 for row in await cursor.fetchall():
                     ret.append(decompress(row[0]))
                 return ret
@@ -285,11 +288,11 @@ class BlockStore:
                 b = FullBlock.from_bytes(block_bytes)
                 return None if b.transactions_generator is None else bytes(b.transactions_generator)
 
-    async def get_generators_at(self, heights: Set[uint32]) -> Dict[uint32, bytes]:
+    async def get_generators_at(self, heights: set[uint32]) -> dict[uint32, bytes]:
         if len(heights) == 0:
             return {}
 
-        generators: Dict[uint32, bytes] = {}
+        generators: dict[uint32, bytes] = {}
         formatted_str = (
             f"SELECT block, height from full_blocks "
             f'WHERE in_main_chain=1 AND height in ({"?," * (len(heights) - 1)}?)'
@@ -317,7 +320,7 @@ class BlockStore:
 
         return generators
 
-    async def get_block_records_by_hash(self, header_hashes: List[bytes32]) -> List[BlockRecord]:
+    async def get_block_records_by_hash(self, header_hashes: list[bytes32]) -> list[BlockRecord]:
         """
         Returns a list of Block Records, ordered by the same order in which header_hashes are passed in.
         Throws an exception if the blocks are not present
@@ -325,7 +328,7 @@ class BlockStore:
         if len(header_hashes) == 0:
             return []
 
-        all_blocks: Dict[bytes32, BlockRecord] = {}
+        all_blocks: dict[bytes32, BlockRecord] = {}
         async with self.db_wrapper.reader_no_transaction() as conn:
             async with conn.execute(
                 "SELECT header_hash,block_record "
@@ -337,7 +340,7 @@ class BlockStore:
                     block_rec = BlockRecord.from_bytes(row[1])
                     all_blocks[block_rec.header_hash] = block_rec
 
-        ret: List[BlockRecord] = []
+        ret: list[BlockRecord] = []
         for hh in header_hashes:
             if hh not in all_blocks:
                 raise ValueError(f"Header hash {hh} not in the blockchain")
@@ -363,7 +366,7 @@ class BlockStore:
                     raise KeyError("missing block in chain")
                 return bytes32(row[0])
 
-    async def get_block_bytes_by_hash(self, header_hashes: List[bytes32]) -> List[bytes]:
+    async def get_block_bytes_by_hash(self, header_hashes: list[bytes32]) -> list[bytes]:
         """
         Returns a list of Full Blocks block blobs, ordered by the same order in which header_hashes are passed in.
         Throws an exception if the blocks are not present
@@ -376,14 +379,14 @@ class BlockStore:
         formatted_str = (
             f'SELECT header_hash, block from full_blocks WHERE header_hash in ({"?," * (len(header_hashes) - 1)}?)'
         )
-        all_blocks: Dict[bytes32, bytes] = {}
+        all_blocks: dict[bytes32, bytes] = {}
         async with self.db_wrapper.reader_no_transaction() as conn:
             async with conn.execute(formatted_str, header_hashes) as cursor:
                 for row in await cursor.fetchall():
                     header_hash = bytes32(row[0])
                     all_blocks[header_hash] = decompress_blob(row[1])
 
-        ret: List[bytes] = []
+        ret: list[bytes] = []
         for hh in header_hashes:
             block = all_blocks.get(hh)
             if block is not None:
@@ -392,7 +395,7 @@ class BlockStore:
                 raise ValueError(f"Header hash {hh} not in the blockchain")
         return ret
 
-    async def get_blocks_by_hash(self, header_hashes: List[bytes32]) -> List[FullBlock]:
+    async def get_blocks_by_hash(self, header_hashes: list[bytes32]) -> list[FullBlock]:
         """
         Returns a list of Full Blocks blocks, ordered by the same order in which header_hashes are passed in.
         Throws an exception if the blocks are not present
@@ -404,7 +407,7 @@ class BlockStore:
         formatted_str = (
             f'SELECT header_hash, block from full_blocks WHERE header_hash in ({"?," * (len(header_hashes) - 1)}?)'
         )
-        all_blocks: Dict[bytes32, FullBlock] = {}
+        all_blocks: dict[bytes32, FullBlock] = {}
         async with self.db_wrapper.reader_no_transaction() as conn:
             async with conn.execute(formatted_str, header_hashes) as cursor:
                 for row in await cursor.fetchall():
@@ -412,7 +415,7 @@ class BlockStore:
                     full_block: FullBlock = decompress(row[1])
                     all_blocks[header_hash] = full_block
                     self.block_cache.put(header_hash, full_block)
-        ret: List[FullBlock] = []
+        ret: list[FullBlock] = []
         for hh in header_hashes:
             if hh not in all_blocks:
                 raise ValueError(f"Header hash {hh} not in the blockchain")
@@ -422,7 +425,7 @@ class BlockStore:
     async def get_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
         async with self.db_wrapper.reader_no_transaction() as conn:
             async with conn.execute(
-                "SELECT block_record " "FROM full_blocks " "WHERE header_hash=?",
+                "SELECT block_record FROM full_blocks WHERE header_hash=?",
                 (header_hash,),
             ) as cursor:
                 row = await cursor.fetchone()
@@ -436,16 +439,18 @@ class BlockStore:
         self,
         start: int,
         stop: int,
-    ) -> Dict[bytes32, BlockRecord]:
+    ) -> dict[bytes32, BlockRecord]:
         """
         Returns a dictionary with all blocks in range between start and stop
-        if present.
+        if present. Only blocks part of the main chain/current peak are returned.
+        i.e. No orphan blocks
         """
 
-        ret: Dict[bytes32, BlockRecord] = {}
+        ret: dict[bytes32, BlockRecord] = {}
         async with self.db_wrapper.reader_no_transaction() as conn:
             async with conn.execute(
-                "SELECT header_hash,block_record " "FROM full_blocks " "WHERE height >= ? AND height <= ?",
+                "SELECT header_hash,block_record FROM full_blocks "
+                "WHERE height >= ? AND height <= ? AND in_main_chain=1",
                 (start, stop),
             ) as cursor:
                 for row in await cursor.fetchall():
@@ -459,24 +464,25 @@ class BlockStore:
         self,
         start: int,
         stop: int,
-    ) -> List[bytes]:
+    ) -> list[bytes]:
         """
         Returns a list with all full blocks in range between start and stop
-        if present.
+        if present. Only includes blocks in the main chain, in the current peak.
+        No orphan blocks.
         """
 
         assert self.db_wrapper.db_version == 2
         async with self.db_wrapper.reader_no_transaction() as conn:
             async with conn.execute(
-                "SELECT block FROM full_blocks WHERE height >= ? AND height <= ? and in_main_chain=1",
+                "SELECT block FROM full_blocks WHERE height >= ? AND height <= ? AND in_main_chain=1",
                 (start, stop),
             ) as cursor:
-                rows: List[sqlite3.Row] = list(await cursor.fetchall())
+                rows: list[sqlite3.Row] = list(await cursor.fetchall())
                 if len(rows) != (stop - start) + 1:
                     raise ValueError(f"Some blocks in range {start}-{stop} were not found.")
                 return [decompress_blob(row[0]) for row in rows]
 
-    async def get_peak(self) -> Optional[Tuple[bytes32, uint32]]:
+    async def get_peak(self) -> Optional[tuple[bytes32, uint32]]:
         async with self.db_wrapper.reader_no_transaction() as conn:
             async with conn.execute("SELECT hash FROM current_peak WHERE key = 0") as cursor:
                 peak_row = await cursor.fetchone()
@@ -491,20 +497,20 @@ class BlockStore:
 
     async def get_block_records_close_to_peak(
         self, blocks_n: int
-    ) -> Tuple[Dict[bytes32, BlockRecord], Optional[bytes32]]:
+    ) -> tuple[dict[bytes32, BlockRecord], Optional[bytes32]]:
         """
         Returns a dictionary with all blocks that have height >= peak height - blocks_n, as well as the
-        peak header hash.
+        peak header hash. Only blocks that are part of the main chain/current peak are included.
         """
 
         peak = await self.get_peak()
         if peak is None:
             return {}, None
 
-        ret: Dict[bytes32, BlockRecord] = {}
+        ret: dict[bytes32, BlockRecord] = {}
         async with self.db_wrapper.reader_no_transaction() as conn:
             async with conn.execute(
-                "SELECT header_hash, block_record " "FROM full_blocks " "WHERE height >= ?",
+                "SELECT header_hash, block_record FROM full_blocks WHERE height >= ? AND in_main_chain=1",
                 (peak[1] - blocks_n,),
             ) as cursor:
                 for row in await cursor.fetchall():
@@ -531,7 +537,7 @@ class BlockStore:
             return None
         return bool(row[0])
 
-    async def get_random_not_compactified(self, number: int) -> List[int]:
+    async def get_random_not_compactified(self, number: int) -> list[int]:
         async with self.db_wrapper.reader_no_transaction() as conn:
             async with conn.execute(
                 f"SELECT height FROM full_blocks WHERE in_main_chain=1 AND is_fully_compactified=0 "

chia/full_node/coin_store.py

@@ -4,7 +4,8 @@ import dataclasses
 import logging
 import sqlite3
 import time
-from typing import Any, Collection, Dict, List, Optional, Set, Tuple
+from collections.abc import Collection
+from typing import Any, Optional
 
 import typing_extensions
 from aiosqlite import Cursor
@@ -31,7 +32,7 @@ class CoinStore:
     """
 
     db_wrapper: DBWrapper2
-    coins_added_at_height_cache: LRUCache[uint32, List[CoinRecord]]
+    coins_added_at_height_cache: LRUCache[uint32, list[CoinRecord]]
 
     @classmethod
     async def create(cls, db_wrapper: DBWrapper2) -> CoinStore:
@@ -85,8 +86,8 @@ class CoinStore:
         timestamp: uint64,
         included_reward_coins: Collection[Coin],
         tx_additions: Collection[Coin],
-        tx_removals: List[bytes32],
-    ) -> List[CoinRecord]:
+        tx_removals: list[bytes32],
+    ) -> list[CoinRecord]:
         """
         Only called for blocks which are blocks (and thus have rewards and transactions)
         Returns a list of the CoinRecords that were added by this block
@@ -148,16 +149,16 @@ class CoinStore:
                     return CoinRecord(coin, row[0], row[1], row[2], row[6])
         return None
 
-    async def get_coin_records(self, names: Collection[bytes32]) -> List[CoinRecord]:
+    async def get_coin_records(self, names: Collection[bytes32]) -> list[CoinRecord]:
         if len(names) == 0:
             return []
 
-        coins: List[CoinRecord] = []
+        coins: list[CoinRecord] = []
 
         async with self.db_wrapper.reader_no_transaction() as conn:
-            cursors: List[Cursor] = []
+            cursors: list[Cursor] = []
             for batch in to_batches(names, SQLITE_MAX_VARIABLE_NUMBER):
-                names_db: Tuple[Any, ...] = tuple(batch.entries)
+                names_db: tuple[Any, ...] = tuple(batch.entries)
                 cursors.append(
                     await conn.execute(
                         f"SELECT confirmed_index, spent_index, coinbase, puzzle_hash, "
@@ -175,8 +176,8 @@ class CoinStore:
 
         return coins
 
-    async def get_coins_added_at_height(self, height: uint32) -> List[CoinRecord]:
-        coins_added: Optional[List[CoinRecord]] = self.coins_added_at_height_cache.get(height)
+    async def get_coins_added_at_height(self, height: uint32) -> list[CoinRecord]:
+        coins_added: Optional[list[CoinRecord]] = self.coins_added_at_height_cache.get(height)
         if coins_added is not None:
             return coins_added
 
@@ -194,7 +195,7 @@ class CoinStore:
                 self.coins_added_at_height_cache.put(height, coins)
                 return coins
 
-    async def get_coins_removed_at_height(self, height: uint32) -> List[CoinRecord]:
+    async def get_coins_removed_at_height(self, height: uint32) -> list[CoinRecord]:
         # Special case to avoid querying all unspent coins (spent_index=0)
         if height == 0:
             return []
@@ -212,7 +213,7 @@ class CoinStore:
                         coins.append(coin_record)
                 return coins
 
-    async def get_all_coins(self, include_spent_coins: bool) -> List[CoinRecord]:
+    async def get_all_coins(self, include_spent_coins: bool) -> list[CoinRecord]:
         # WARNING: this should only be used for testing or in a simulation,
         # running it on a synced testnet or mainnet node will most likely result in an OOM error.
         coins = set()
@@ -236,7 +237,7 @@ class CoinStore:
         puzzle_hash: bytes32,
         start_height: uint32 = uint32(0),
         end_height: uint32 = uint32((2**32) - 1),
-    ) -> List[CoinRecord]:
+    ) -> list[CoinRecord]:
         coins = set()
 
         async with self.db_wrapper.reader_no_transaction() as conn:
@@ -255,15 +256,15 @@ class CoinStore:
     async def get_coin_records_by_puzzle_hashes(
         self,
         include_spent_coins: bool,
-        puzzle_hashes: List[bytes32],
+        puzzle_hashes: list[bytes32],
         start_height: uint32 = uint32(0),
         end_height: uint32 = uint32((2**32) - 1),
-    ) -> List[CoinRecord]:
+    ) -> list[CoinRecord]:
         if len(puzzle_hashes) == 0:
             return []
 
         coins = set()
-        puzzle_hashes_db: Tuple[Any, ...]
+        puzzle_hashes_db: tuple[Any, ...]
         puzzle_hashes_db = tuple(puzzle_hashes)
 
         async with self.db_wrapper.reader_no_transaction() as conn:
@@ -273,7 +274,7 @@ class CoinStore:
                 f'WHERE puzzle_hash in ({"?," * (len(puzzle_hashes) - 1)}?) '
                 f"AND confirmed_index>=? AND confirmed_index<? "
                 f"{'' if include_spent_coins else 'AND spent_index=0'}",
-                puzzle_hashes_db + (start_height, end_height),
+                (*puzzle_hashes_db, start_height, end_height),
             ) as cursor:
                 for row in await cursor.fetchall():
                     coin = self.row_to_coin(row)
@@ -283,10 +284,10 @@ class CoinStore:
     async def get_coin_records_by_names(
         self,
         include_spent_coins: bool,
-        names: List[bytes32],
+        names: list[bytes32],
         start_height: uint32 = uint32(0),
         end_height: uint32 = uint32((2**32) - 1),
-    ) -> List[CoinRecord]:
+    ) -> list[CoinRecord]:
         if len(names) == 0:
             return []
 
@@ -299,7 +300,7 @@ class CoinStore:
                 f'WHERE coin_name in ({"?," * (len(names) - 1)}?) '
                 f"AND confirmed_index>=? AND confirmed_index<? "
                 f"{'' if include_spent_coins else 'AND spent_index=0'}",
-                names + [start_height, end_height],
+                [*names, start_height, end_height],
             ) as cursor:
                 for row in await cursor.fetchall():
                     coin = self.row_to_coin(row)
@@ -320,18 +321,18 @@ class CoinStore:
     async def get_coin_states_by_puzzle_hashes(
         self,
         include_spent_coins: bool,
-        puzzle_hashes: Set[bytes32],
+        puzzle_hashes: set[bytes32],
         min_height: uint32 = uint32(0),
         *,
         max_items: int = 50000,
-    ) -> Set[CoinState]:
+    ) -> set[CoinState]:
         if len(puzzle_hashes) == 0:
             return set()
 
-        coins: Set[CoinState] = set()
+        coins: set[CoinState] = set()
         async with self.db_wrapper.reader_no_transaction() as conn:
             for batch in to_batches(puzzle_hashes, SQLITE_MAX_VARIABLE_NUMBER):
-                puzzle_hashes_db: Tuple[Any, ...] = tuple(batch.entries)
+                puzzle_hashes_db: tuple[Any, ...] = tuple(batch.entries)
                 async with conn.execute(
                     f"SELECT confirmed_index, spent_index, coinbase, puzzle_hash, "
                     f"coin_parent, amount, timestamp FROM coin_record INDEXED BY coin_puzzle_hash "
@@ -339,7 +340,7 @@ class CoinStore:
                     f"AND (confirmed_index>=? OR spent_index>=?)"
                     f"{'' if include_spent_coins else 'AND spent_index=0'}"
                     " LIMIT ?",
-                    puzzle_hashes_db + (min_height, min_height, max_items - len(coins)),
+                    (*puzzle_hashes_db, min_height, min_height, max_items - len(coins)),
                 ) as cursor:
                     row: sqlite3.Row
                     for row in await cursor.fetchall():
@@ -353,23 +354,23 @@ class CoinStore:
     async def get_coin_records_by_parent_ids(
         self,
         include_spent_coins: bool,
-        parent_ids: List[bytes32],
+        parent_ids: list[bytes32],
         start_height: uint32 = uint32(0),
         end_height: uint32 = uint32((2**32) - 1),
-    ) -> List[CoinRecord]:
+    ) -> list[CoinRecord]:
         if len(parent_ids) == 0:
             return []
 
         coins = set()
         async with self.db_wrapper.reader_no_transaction() as conn:
             for batch in to_batches(parent_ids, SQLITE_MAX_VARIABLE_NUMBER):
-                parent_ids_db: Tuple[Any, ...] = tuple(batch.entries)
+                parent_ids_db: tuple[Any, ...] = tuple(batch.entries)
                 async with conn.execute(
                     f"SELECT confirmed_index, spent_index, coinbase, puzzle_hash, coin_parent, amount, timestamp "
                     f'FROM coin_record WHERE coin_parent in ({"?," * (len(batch.entries) - 1)}?) '
                     f"AND confirmed_index>=? AND confirmed_index<? "
                     f"{'' if include_spent_coins else 'AND spent_index=0'}",
-                    parent_ids_db + (start_height, end_height),
+                    (*parent_ids_db, start_height, end_height),
                 ) as cursor:
                     async for row in cursor:
                         coin = self.row_to_coin(row)
@@ -385,14 +386,14 @@ class CoinStore:
         *,
         max_height: uint32 = uint32.MAXIMUM,
         max_items: int = 50000,
-    ) -> List[CoinState]:
+    ) -> list[CoinState]:
         if len(coin_ids) == 0:
             return []
 
-        coins: List[CoinState] = []
+        coins: list[CoinState] = []
         async with self.db_wrapper.reader_no_transaction() as conn:
             for batch in to_batches(coin_ids, SQLITE_MAX_VARIABLE_NUMBER):
-                coin_ids_db: Tuple[Any, ...] = tuple(batch.entries)
+                coin_ids_db: tuple[Any, ...] = tuple(batch.entries)
 
                 max_height_sql = ""
                 if max_height != uint32.MAXIMUM:
@@ -404,7 +405,7 @@ class CoinStore:
                     f"AND (confirmed_index>=? OR spent_index>=?) {max_height_sql}"
                     f"{'' if include_spent_coins else 'AND spent_index=0'}"
                     " LIMIT ?",
-                    coin_ids_db + (min_height, min_height, max_items - len(coins)),
+                    (*coin_ids_db, min_height, min_height, max_items - len(coins)),
                 ) as cursor:
                     for row in await cursor.fetchall():
                         coins.append(self.row_to_coin_state(row))
@@ -417,7 +418,7 @@ class CoinStore:
 
     async def batch_coin_states_by_puzzle_hashes(
         self,
-        puzzle_hashes: List[bytes32],
+        puzzle_hashes: list[bytes32],
         *,
         min_height: uint32 = uint32(0),
         include_spent: bool = True,
@@ -425,7 +426,7 @@ class CoinStore:
         include_hinted: bool = True,
         min_amount: uint64 = uint64(0),
         max_items: int = 50000,
-    ) -> Tuple[List[CoinState], Optional[uint32]]:
+    ) -> tuple[list[CoinState], Optional[uint32]]:
         """
         Returns the coin states, as well as the next block height (or `None` if finished).
         You cannot exceed `CoinStore.MAX_PUZZLE_HASH_BATCH_SIZE` puzzle hashes in the query.
@@ -439,8 +440,8 @@ class CoinStore:
             return [], None
 
         # Coin states are keyed by coin id to filter out and prevent duplicates.
-        coin_states_dict: Dict[bytes32, CoinState] = dict()
-        coin_states: List[CoinState]
+        coin_states_dict: dict[bytes32, CoinState] = dict()
+        coin_states: list[CoinState]
 
         async with self.db_wrapper.reader() as conn:
             puzzle_hashes_db = tuple(puzzle_hashes)
@@ -530,13 +531,13 @@ class CoinStore:
 
         return coin_states, next_height
 
-    async def rollback_to_block(self, block_index: int) -> List[CoinRecord]:
+    async def rollback_to_block(self, block_index: int) -> list[CoinRecord]:
         """
         Note that block_index can be negative, in which case everything is rolled back
         Returns the list of coin records that have been modified
         """
 
-        coin_changes: Dict[bytes32, CoinRecord] = {}
+        coin_changes: dict[bytes32, CoinRecord] = {}
         # Add coins that are confirmed in the reverted blocks to the list of updated coins.
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             async with conn.execute(
@@ -569,7 +570,7 @@ class CoinStore:
         return list(coin_changes.values())
 
     # Store CoinRecord in DB
-    async def _add_coin_records(self, records: List[CoinRecord]) -> None:
+    async def _add_coin_records(self, records: list[CoinRecord]) -> None:
         values2 = []
         for record in records:
             values2.append(
@@ -592,7 +593,7 @@ class CoinStore:
                 )
 
     # Update coin_record to be spent in DB
-    async def _set_spent(self, coin_names: List[bytes32], index: uint32) -> None:
+    async def _set_spent(self, coin_names: list[bytes32], index: uint32) -> None:
         assert len(coin_names) == 0 or index > 0
 
         if len(coin_names) == 0:

chia/full_node/fee_estimate.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import math
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 
 from chia.types.fee_rate import FeeRate, FeeRateV2
 from chia.util.ints import uint64
@@ -51,4 +51,4 @@ class FeeEstimateGroup(Streamable):
     """
 
     error: Optional[str]
-    estimates: List[FeeEstimate]
+    estimates: list[FeeEstimate]

chia/full_node/fee_estimation.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from datetime import datetime
-from typing import List
 
 from chia.types.clvm_cost import CLVMCost
 from chia.types.fee_rate import FeeRate
@@ -90,4 +89,4 @@ class FeeBlockInfo:  # See BlockRecord
     """
 
     block_height: uint32
-    included_items: List[MempoolItemInfo]
+    included_items: list[MempoolItemInfo]

chia/full_node/fee_history.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List
 
 from chia.util.ints import uint8, uint32
 from chia.util.streamable import Streamable, streamable
@@ -11,10 +10,10 @@ from chia.util.streamable import Streamable, streamable
 @dataclass(frozen=True)
 class FeeStatBackup(Streamable):
     type: str
-    tx_ct_avg: List[str]
-    confirmed_average: List[List[str]]
-    failed_average: List[List[str]]
-    m_fee_rate_avg: List[str]
+    tx_ct_avg: list[str]
+    confirmed_average: list[list[str]]
+    failed_average: list[list[str]]
+    m_fee_rate_avg: list[str]
 
 
 @streamable
@@ -23,4 +22,4 @@ class FeeTrackerBackup(Streamable):
     fee_estimator_version: uint8
     first_recorded_height: uint32
     latest_seen_height: uint32
-    stats: List[FeeStatBackup]
+    stats: list[FeeStatBackup]