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

chia/wallet/wallet_coin_record.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -56,7 +56,7 @@ class WalletCoinRecord:
     def to_coin_record(self, timestamp: uint64) -> CoinRecord:
         return CoinRecord(self.coin, self.confirmed_block_height, self.spent_block_height, self.coinbase, timestamp)
 
-    def to_json_dict_parsed_metadata(self) -> Dict[str, Any]:
+    def to_json_dict_parsed_metadata(self) -> dict[str, Any]:
         # TODO: Merge wallet_type and wallet_id into `wallet_identifier`, make `spent` an attribute based
         #  on `spent_height` make `WalletCoinRecord` streamable and use Streamable.to_json_dict as base here if we have
         #  streamable enums.

chia/wallet/wallet_coin_store.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import sqlite3
 from dataclasses import dataclass
 from enum import IntEnum
-from typing import Dict, List, Optional, Set
+from typing import Optional
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -47,8 +47,8 @@ class GetCoinRecords(Streamable):
 
 @dataclass(frozen=True)
 class GetCoinRecordsResult:
-    records: List[WalletCoinRecord]
-    coin_id_to_record: Dict[bytes32, WalletCoinRecord]
+    records: list[WalletCoinRecord]
+    coin_id_to_record: dict[bytes32, WalletCoinRecord]
     total_count: Optional[uint32]
 
 
@@ -252,8 +252,8 @@ class WalletCoinStore:
                     total_count = uint32(row[0])
                     self.total_count_cache.put(cache_hash, total_count)
 
-        records: List[WalletCoinRecord] = []
-        coin_id_to_record: Dict[bytes32, WalletCoinRecord] = {}
+        records: list[WalletCoinRecord] = []
+        coin_id_to_record: dict[bytes32, WalletCoinRecord] = {}
         for row in rows:
             records.append(self.coin_record_from_row(row))
             coin_id_to_record[bytes32.fromhex(row[0])] = records[-1]
@@ -266,7 +266,7 @@ class WalletCoinStore:
 
     async def get_coin_records_between(
         self, wallet_id: int, start: int, end: int, reverse: bool = False, coin_type: CoinType = CoinType.NORMAL
-    ) -> List[WalletCoinRecord]:
+    ) -> list[WalletCoinRecord]:
         """Return a list of coins between start and end index. List is in reverse chronological order.
         start = 0 is most recent transaction
         """
@@ -293,7 +293,7 @@ class WalletCoinStore:
 
     async def get_unspent_coins_for_wallet(
         self, wallet_id: int, coin_type: CoinType = CoinType.NORMAL
-    ) -> Set[WalletCoinRecord]:
+    ) -> set[WalletCoinRecord]:
         """Returns set of CoinRecords that have not been spent yet for a wallet."""
         async with self.db_wrapper.reader_no_transaction() as conn:
             rows = await conn.execute_fetchall(
@@ -302,7 +302,7 @@ class WalletCoinStore:
             )
         return {self.coin_record_from_row(row) for row in rows}
 
-    async def get_all_unspent_coins(self, coin_type: CoinType = CoinType.NORMAL) -> Set[WalletCoinRecord]:
+    async def get_all_unspent_coins(self, coin_type: CoinType = CoinType.NORMAL) -> set[WalletCoinRecord]:
         """Returns set of CoinRecords that have not been spent yet for a wallet."""
         async with self.db_wrapper.reader_no_transaction() as conn:
             rows = await conn.execute_fetchall(
@@ -311,7 +311,7 @@ class WalletCoinStore:
         return {self.coin_record_from_row(row) for row in rows}
 
     # Checks DB and DiffStores for CoinRecords with puzzle_hash and returns them
-    async def get_coin_records_by_puzzle_hash(self, puzzle_hash: bytes32) -> List[WalletCoinRecord]:
+    async def get_coin_records_by_puzzle_hash(self, puzzle_hash: bytes32) -> list[WalletCoinRecord]:
         """Returns a list of all coin records with the given puzzle hash"""
         async with self.db_wrapper.reader_no_transaction() as conn:
             rows = await conn.execute_fetchall("SELECT * from coin_record WHERE puzzle_hash=?", (puzzle_hash.hex(),))
@@ -319,7 +319,7 @@ class WalletCoinStore:
         return [self.coin_record_from_row(row) for row in rows]
 
     # Checks DB and DiffStores for CoinRecords with parent_coin_info and returns them
-    async def get_coin_records_by_parent_id(self, parent_coin_info: bytes32) -> List[WalletCoinRecord]:
+    async def get_coin_records_by_parent_id(self, parent_coin_info: bytes32) -> list[WalletCoinRecord]:
         """Returns a list of all coin records with the given parent id"""
         async with self.db_wrapper.reader_no_transaction() as conn:
             rows = await conn.execute_fetchall(

chia/wallet/wallet_info.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
@@ -33,4 +32,4 @@ class WalletInfoBackup(Streamable):
     Used for transforming list of WalletInfo objects into bytes.
     """
 
-    wallet_list: List[WalletInfo]
+    wallet_list: list[WalletInfo]

chia/wallet/wallet_interested_store.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import List, Optional, Tuple
+from typing import Optional
 
 from chia.protocols.wallet_protocol import CoinState
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -38,7 +38,7 @@ class WalletInterestedStore:
 
         return self
 
-    async def get_interested_coin_ids(self) -> List[bytes32]:
+    async def get_interested_coin_ids(self) -> list[bytes32]:
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             cursor = await conn.execute("SELECT coin_name FROM interested_coins")
             rows_hex = await cursor.fetchall()
@@ -54,7 +54,7 @@ class WalletInterestedStore:
             cursor = await conn.execute("DELETE FROM interested_coins WHERE coin_name=?", (coin_id.hex(),))
             await cursor.close()
 
-    async def get_interested_puzzle_hashes(self) -> List[Tuple[bytes32, int]]:
+    async def get_interested_puzzle_hashes(self) -> list[tuple[bytes32, int]]:
         async with self.db_wrapper.reader_no_transaction() as conn:
             cursor = await conn.execute("SELECT puzzle_hash, wallet_id FROM interested_puzzle_hashes")
             rows_hex = await cursor.fetchall()
@@ -111,7 +111,7 @@ class WalletInterestedStore:
             )
             await cursor.close()
 
-    async def get_unacknowledged_tokens(self) -> List:
+    async def get_unacknowledged_tokens(self) -> list:
         """
         Get a list of all unacknowledged CATs
         :return: A json style list of unacknowledged CATs
@@ -147,7 +147,7 @@ class WalletInterestedStore:
             )
             await cursor.close()
 
-    async def get_unacknowledged_states_for_asset_id(self, asset_id: bytes32) -> List[Tuple[CoinState, uint32]]:
+    async def get_unacknowledged_states_for_asset_id(self, asset_id: bytes32) -> list[tuple[CoinState, uint32]]:
         """
         Return all states for a particular asset ID that were ignored
         :param asset_id: CAT asset ID

chia/wallet/wallet_nft_store.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import logging
 from sqlite3 import Row
-from typing import List, Optional, Type, TypeVar, Union
+from typing import Optional, TypeVar, Union
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -41,7 +41,7 @@ class WalletNftStore:
     db_wrapper: DBWrapper2
 
     @classmethod
-    async def create(cls: Type[_T_WalletNftStore], db_wrapper: DBWrapper2) -> _T_WalletNftStore:
+    async def create(cls: type[_T_WalletNftStore], db_wrapper: DBWrapper2) -> _T_WalletNftStore:
         self = cls()
         self.db_wrapper = db_wrapper
         async with self.db_wrapper.writer_maybe_transaction() as conn:
@@ -144,7 +144,7 @@ class WalletNftStore:
 
     async def count(self, wallet_id: Optional[uint32] = None, did_id: Optional[bytes32] = None) -> int:
         sql = "SELECT COUNT(nft_id) FROM users_nfts WHERE removed_height is NULL"
-        params: List[Union[uint32, bytes32]] = []
+        params: list[Union[uint32, bytes32]] = []
         if wallet_id is not None:
             sql += " AND wallet_id=?"
             params.append(wallet_id)
@@ -159,7 +159,7 @@ class WalletNftStore:
 
     async def is_empty(self, wallet_id: Optional[uint32] = None) -> bool:
         sql = "SELECT 1 FROM users_nfts WHERE removed_height is NULL"
-        params: List[Union[uint32, bytes32]] = []
+        params: list[Union[uint32, bytes32]] = []
         if wallet_id is not None:
             sql += " AND wallet_id=?"
             params.append(wallet_id)
@@ -176,7 +176,7 @@ class WalletNftStore:
         did_id: Optional[bytes32] = None,
         start_index: int = 0,
         count: int = 50,
-    ) -> List[NFTCoinInfo]:
+    ) -> list[NFTCoinInfo]:
         try:
             start_index = int(start_index)
         except ValueError:
@@ -240,7 +240,7 @@ class WalletNftStore:
     async def get_nft_by_id(self, nft_id: bytes32, wallet_id: Optional[uint32] = None) -> Optional[NFTCoinInfo]:
         async with self.db_wrapper.reader_no_transaction() as conn:
             sql = f"SELECT {NFT_COIN_INFO_COLUMNS} from users_nfts WHERE removed_height is NULL and nft_id=?"
-            params: List[Union[uint32, str]] = [nft_id.hex()]
+            params: list[Union[uint32, str]] = [nft_id.hex()]
             if wallet_id:
                 sql += " and wallet_id=?"
                 params.append(wallet_id)

chia/wallet/wallet_node.py

@@ -9,22 +9,9 @@ import random
 import sys
 import time
 import traceback
+from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncIterator,
-    ClassVar,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Set,
-    Tuple,
-    Union,
-    cast,
-    overload,
-)
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, Optional, Union, cast, overload
 
 import aiosqlite
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
@@ -68,6 +55,7 @@ from chia.util.keychain import Keychain
 from chia.util.path import path_from_root
 from chia.util.profiler import mem_profile_task, profile_task
 from chia.util.streamable import Streamable, streamable
+from chia.util.task_referencer import create_referenced_task
 from chia.wallet.puzzles.clawback.metadata import AutoClaimSettings
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.new_peak_queue import NewPeakItem, NewPeakQueue, NewPeakQueueTypes
@@ -88,7 +76,7 @@ from chia.wallet.wallet_state_manager import WalletStateManager
 from chia.wallet.wallet_weight_proof_handler import WalletWeightProofHandler, get_wp_fork_point
 
 
-def get_wallet_db_path(root_path: Path, config: Dict[str, Any], key_fingerprint: str) -> Path:
+def get_wallet_db_path(root_path: Path, config: dict[str, Any], key_fingerprint: str) -> Path:
     """
     Construct a path to the wallet db. Uses config values and the wallet key's fingerprint to
     determine the wallet db filename.
@@ -124,7 +112,7 @@ class WalletNode:
 
         _protocol_check: ClassVar[RpcServiceProtocol] = cast("WalletNode", None)
 
-    config: Dict[str, Any]
+    config: dict[str, Any]
     root_path: Path
     constants: ConsensusConstants
     local_keychain: Optional[Keychain] = None
@@ -140,11 +128,11 @@ class WalletNode:
     logged_in_fingerprint: Optional[int] = None
     logged_in: bool = False
     _keychain_proxy: Optional[KeychainProxy] = None
-    _balance_cache: Dict[int, Balance] = dataclasses.field(default_factory=dict)
+    _balance_cache: dict[int, Balance] = dataclasses.field(default_factory=dict)
     # Peers that we have long synced to
-    synced_peers: Set[bytes32] = dataclasses.field(default_factory=set)
+    synced_peers: set[bytes32] = dataclasses.field(default_factory=set)
     wallet_peers: Optional[WalletPeers] = None
-    peer_caches: Dict[bytes32, PeerRequestCache] = dataclasses.field(default_factory=dict)
+    peer_caches: dict[bytes32, PeerRequestCache] = dataclasses.field(default_factory=dict)
     validation_semaphore: Optional[asyncio.Semaphore] = None
     local_node_synced: bool = False
     LONG_SYNC_THRESHOLD: int = 300
@@ -158,7 +146,7 @@ class WalletNode:
     _process_new_subscriptions_task: Optional[asyncio.Task[None]] = None
     _retry_failed_states_task: Optional[asyncio.Task[None]] = None
     _secondary_peer_sync_task: Optional[asyncio.Task[None]] = None
-    _tx_messages_in_progress: Dict[bytes32, List[bytes32]] = dataclasses.field(default_factory=dict)
+    _tx_messages_in_progress: dict[bytes32, list[bytes32]] = dataclasses.field(default_factory=dict)
 
     @contextlib.asynccontextmanager
     async def manage(self) -> AsyncIterator[None]:
@@ -205,7 +193,7 @@ class WalletNode:
 
         return self._new_peak_queue
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> List[Dict[str, Any]]:
+    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     async def ensure_keychain_proxy(self) -> KeychainProxy:
@@ -306,7 +294,7 @@ class WalletNode:
                     self.log.info("Disabled resync for wallet fingerprint: %s", fingerprint)
             save_config(self.root_path, "config.yaml", config)
 
-    def set_auto_claim(self, auto_claim_config: AutoClaimSettings) -> Dict[str, Any]:
+    def set_auto_claim(self, auto_claim_config: AutoClaimSettings) -> dict[str, Any]:
         if auto_claim_config.batch_size < 1:
             auto_claim_config = dataclasses.replace(auto_claim_config, batch_size=uint16(50))
         auto_claim_config_json = auto_claim_config.to_json_dict()
@@ -356,7 +344,7 @@ class WalletNode:
             self.log.info("Resetting wallet sync data...")
             rows = list(await conn.execute_fetchall("SELECT name FROM sqlite_master WHERE type='table'"))
             names = {x[0] for x in rows}
-            names = names - set(known_tables)
+            names -= set(known_tables)
             tables_to_drop = []
             for name in names:
                 for ignore_name in ignore_tables:
@@ -439,10 +427,10 @@ class WalletNode:
             if sys.getprofile() is not None:
                 self.log.warning("not enabling profiler, getprofile() is already set")
             else:
-                asyncio.create_task(profile_task(self.root_path, "wallet", self.log))
+                create_referenced_task(profile_task(self.root_path, "wallet", self.log), known_unreferenced=True)
 
         if self.config.get("enable_memory_profiler", False):
-            asyncio.create_task(mem_profile_task(self.root_path, "wallet", self.log))
+            create_referenced_task(mem_profile_task(self.root_path, "wallet", self.log), known_unreferenced=True)
 
         path: Path = get_wallet_db_path(self.root_path, self.config, str(fingerprint))
         path.parent.mkdir(parents=True, exist_ok=True)
@@ -468,8 +456,8 @@ class WalletNode:
         self.wallet_tx_resend_timeout_secs = self.config.get("tx_resend_timeout_secs", 60 * 60)
         self.wallet_state_manager.set_pending_callback(self._pending_tx_handler)
         self._shut_down = False
-        self._process_new_subscriptions_task = asyncio.create_task(self._process_new_subscriptions())
-        self._retry_failed_states_task = asyncio.create_task(self._retry_failed_states())
+        self._process_new_subscriptions_task = create_referenced_task(self._process_new_subscriptions())
+        self._retry_failed_states_task = create_referenced_task(self._retry_failed_states())
 
         self.sync_event = asyncio.Event()
         self.log_in(fingerprint)
@@ -530,7 +518,7 @@ class WalletNode:
     def _pending_tx_handler(self) -> None:
         if self._wallet_state_manager is None:
             return None
-        asyncio.create_task(self._resend_queue())
+        create_referenced_task(self._resend_queue(), known_unreferenced=True)
 
     async def _resend_queue(self) -> None:
         if self._shut_down or self._server is None or self._wallet_state_manager is None:
@@ -554,17 +542,17 @@ class WalletNode:
                 self._tx_messages_in_progress.setdefault(peer.peer_node_id, [])
                 self._tx_messages_in_progress[peer.peer_node_id].append(msg_name)
 
-    async def _messages_to_resend(self) -> List[Tuple[Message, Set[bytes32]]]:
+    async def _messages_to_resend(self) -> list[tuple[Message, set[bytes32]]]:
         if self._wallet_state_manager is None or self._shut_down:
             return []
-        messages: List[Tuple[Message, Set[bytes32]]] = []
+        messages: list[tuple[Message, set[bytes32]]] = []
 
         current_time = int(time.time())
         retry_accepted_txs = False
         if self.last_wallet_tx_resend_time < current_time - self.wallet_tx_resend_timeout_secs:
             self.last_wallet_tx_resend_time = current_time
             retry_accepted_txs = True
-        records: List[TransactionRecord] = await self.wallet_state_manager.tx_store.get_not_sent(
+        records: list[TransactionRecord] = await self.wallet_state_manager.tx_store.get_not_sent(
             include_accepted_txs=retry_accepted_txs
         )
 
@@ -626,15 +614,15 @@ class WalletNode:
                     # Subscriptions are the highest priority, because we don't want to process any more peaks or
                     # state updates until we are sure that we subscribed to everything that we need to. Otherwise,
                     # we might not be able to process some state.
-                    coin_ids: List[bytes32] = item.data
+                    coin_ids: list[bytes32] = item.data
                     for peer in self.server.get_connections(NodeType.FULL_NODE):
-                        coin_states: List[CoinState] = await subscribe_to_coin_updates(coin_ids, peer, 0)
+                        coin_states: list[CoinState] = await subscribe_to_coin_updates(coin_ids, peer, 0)
                         if len(coin_states) > 0:
                             async with self.wallet_state_manager.lock:
                                 await self.add_states_from_peer(coin_states, peer)
                 elif item.item_type == NewPeakQueueTypes.PUZZLE_HASH_SUBSCRIPTION:
                     self.log.debug("Pulled from queue: %s %s", item.item_type.name, item.data)
-                    puzzle_hashes: List[bytes32] = item.data
+                    puzzle_hashes: list[bytes32] = item.data
                     for peer in self.server.get_connections(NodeType.FULL_NODE):
                         # Puzzle hash subscription
                         coin_states = await subscribe_to_phs(puzzle_hashes, peer, 0)
@@ -731,7 +719,7 @@ class WalletNode:
                 default_port,
                 self.log,
             )
-            asyncio.create_task(self.wallet_peers.start())
+            create_referenced_task(self.wallet_peers.start())
 
     async def on_disconnect(self, peer: WSChiaConnection) -> None:
         if self.is_trusted(peer):
@@ -839,7 +827,7 @@ class WalletNode:
         # Things, so we don't have to reprocess these later. There can be many things in ph_update_res.
         use_delta_sync = self.config.get("use_delta_sync", False)
         min_height_for_subscriptions = fork_height if use_delta_sync else 0
-        already_checked_ph: Set[bytes32] = set()
+        already_checked_ph: set[bytes32] = set()
         while not self._shut_down:
             await self.wallet_state_manager.create_more_puzzle_hashes()
             all_puzzle_hashes = await self.get_puzzle_hashes_to_subscribe()
@@ -847,7 +835,7 @@ class WalletNode:
             if not_checked_puzzle_hashes == set():
                 break
             for batch in to_batches(not_checked_puzzle_hashes, 1000):
-                ph_update_res: List[CoinState] = await subscribe_to_phs(
+                ph_update_res: list[CoinState] = await subscribe_to_phs(
                     batch.entries, full_node, min_height_for_subscriptions
                 )
                 ph_update_res = list(filter(is_new_state_update, ph_update_res))
@@ -860,14 +848,14 @@ class WalletNode:
 
         # The number of coin id updates are usually going to be significantly less than ph updates, so we can
         # sync from 0 every time.
-        already_checked_coin_ids: Set[bytes32] = set()
+        already_checked_coin_ids: set[bytes32] = set()
         while not self._shut_down:
             all_coin_ids = await self.get_coin_ids_to_subscribe()
             not_checked_coin_ids = set(all_coin_ids) - already_checked_coin_ids
             if not_checked_coin_ids == set():
                 break
             for batch in to_batches(not_checked_coin_ids, 1000):
-                c_update_res: List[CoinState] = await subscribe_to_coin_updates(
+                c_update_res: list[CoinState] = await subscribe_to_coin_updates(
                     batch.entries, full_node, min_height_for_subscriptions
                 )
 
@@ -892,7 +880,7 @@ class WalletNode:
 
     async def add_states_from_peer(
         self,
-        items_input: List[CoinState],
+        items_input: list[CoinState],
         peer: WSChiaConnection,
         fork_height: Optional[uint32] = None,
         height: Optional[uint32] = None,
@@ -932,7 +920,7 @@ class WalletNode:
                     # Rollback race_cache not in clear_after_height to avoid applying rollbacks from new peak processing
                     cache.rollback_race_cache(fork_height=fork_height)
 
-        all_tasks: List[asyncio.Task[None]] = []
+        all_tasks: list[asyncio.Task[None]] = []
         target_concurrent_tasks: int = 30
 
         # Ensure the list is sorted
@@ -943,7 +931,7 @@ class WalletNode:
         if num_filtered > 0:
             self.log.info(f"Filtered {num_filtered} spam transactions")
 
-        async def validate_and_add(inner_states: List[CoinState], inner_idx_start: int) -> None:
+        async def validate_and_add(inner_states: list[CoinState], inner_idx_start: int) -> None:
             try:
                 assert self.validation_semaphore is not None
                 async with self.validation_semaphore:
@@ -1012,7 +1000,7 @@ class WalletNode:
                             self.log.info("Terminating receipt and validation due to shut down request")
                             await asyncio.gather(*all_tasks)
                             return False
-                    all_tasks.append(asyncio.create_task(validate_and_add(batch.entries, idx)))
+                    all_tasks.append(create_referenced_task(validate_and_add(batch.entries, idx)))
             idx += len(batch.entries)
 
         still_connected = self._server is not None and peer.peer_node_id in self.server.all_connections
@@ -1046,12 +1034,12 @@ class WalletNode:
         """
         Get a full node, preferring synced & trusted > synced & untrusted > unsynced & trusted > unsynced & untrusted
         """
-        full_nodes: List[WSChiaConnection] = self.get_full_node_peers_in_order()
+        full_nodes: list[WSChiaConnection] = self.get_full_node_peers_in_order()
         if len(full_nodes) == 0:
             raise ValueError("No peer connected")
         return full_nodes[0]
 
-    def get_full_node_peers_in_order(self) -> List[WSChiaConnection]:
+    def get_full_node_peers_in_order(self) -> list[WSChiaConnection]:
         """
         Get all full nodes sorted:
          preferring synced & trusted > synced & untrusted > unsynced & trusted > unsynced & untrusted
@@ -1059,11 +1047,11 @@ class WalletNode:
         if self._server is None:
             return []
 
-        synced_and_trusted: List[WSChiaConnection] = []
-        synced: List[WSChiaConnection] = []
-        trusted: List[WSChiaConnection] = []
-        neither: List[WSChiaConnection] = []
-        all_nodes: List[WSChiaConnection] = self.server.get_connections(NodeType.FULL_NODE)
+        synced_and_trusted: list[WSChiaConnection] = []
+        synced: list[WSChiaConnection] = []
+        trusted: list[WSChiaConnection] = []
+        neither: list[WSChiaConnection] = []
+        all_nodes: list[WSChiaConnection] = self.server.get_connections(NodeType.FULL_NODE)
         random.shuffle(all_nodes)
         for node in all_nodes:
             we_synced_to_it = node.peer_node_id in self.synced_peers
@@ -1092,7 +1080,7 @@ class WalletNode:
             block = cache.get_block(uint32(request_height))
             if block is None:
                 self.log.debug(f"get_timestamp_for_height_from_peer cache miss for height {request_height}")
-                response: Optional[List[HeaderBlock]] = await request_header_blocks(
+                response: Optional[list[HeaderBlock]] = await request_header_blocks(
                     peer, uint32(request_height), uint32(request_height)
                 )
                 if response is not None and len(response) > 0:
@@ -1124,10 +1112,14 @@ class WalletNode:
             # When logging out of wallet
             self.log.debug("state manager is None (shutdown)")
             return
-        trusted: bool = self.is_trusted(peer)
+
         peak_hb: Optional[HeaderBlock] = await self.wallet_state_manager.blockchain.get_peak_block()
+        if peak_hb is not None and peak_hb.header_hash == new_peak.header_hash:
+            self.log.debug("skip known peak.")
+            return
+
         if peak_hb is not None and new_peak.weight < peak_hb.weight:
-            # Discards old blocks, but accepts blocks that are equal in weight to peak
+            # Discards old blocks,  accept only heavier peaks blocks that are equal in weight to peak
             self.log.debug("skip block with lower weight.")
             return
 
@@ -1152,6 +1144,7 @@ class WalletNode:
             # dont disconnect from peer, this might be a reorg
             return
 
+        trusted: bool = self.is_trusted(peer)
         latest_timestamp = await self.get_timestamp_for_height_from_peer(new_peak_hb.height, peer)
         if latest_timestamp is None or not self.is_timestamp_in_sync(latest_timestamp):
             if trusted:
@@ -1162,7 +1155,9 @@ class WalletNode:
             return
 
         if self.is_trusted(peer):
-            await self.new_peak_from_trusted(new_peak_hb, latest_timestamp, peer)
+            await self.new_peak_from_trusted(
+                new_peak_hb, latest_timestamp, peer, new_peak.fork_point_with_previous_peak
+            )
         else:
             if not await self.new_peak_from_untrusted(new_peak_hb, peer):
                 return
@@ -1179,15 +1174,16 @@ class WalletNode:
             await self.wallet_state_manager.blockchain.set_finished_sync_up_to(new_peak.height)
 
     async def new_peak_from_trusted(
-        self, new_peak_hb: HeaderBlock, latest_timestamp: uint64, peer: WSChiaConnection
+        self, new_peak_hb: HeaderBlock, latest_timestamp: uint64, peer: WSChiaConnection, fork_point: uint32
     ) -> None:
         async with self.wallet_state_manager.set_sync_mode(new_peak_hb.height) as current_height:
             await self.wallet_state_manager.blockchain.set_peak_block(new_peak_hb, latest_timestamp)
-            # Sync to trusted node if we haven't done so yet. As long as we have synced once (and not
-            # disconnected), we assume that the full node will continue to give us state updates, so we do
-            # not need to resync.
             if peer.peer_node_id not in self.synced_peers:
                 await self.long_sync(new_peak_hb.height, peer, uint32(max(0, current_height - 256)), rollback=True)
+            elif fork_point < current_height - 1:
+                await self.long_sync(
+                    new_peak_hb.height, peer, uint32(min(fork_point, current_height - 256)), rollback=True
+                )
 
     async def new_peak_from_untrusted(self, new_peak_hb: HeaderBlock, peer: WSChiaConnection) -> bool:
         far_behind: bool = (
@@ -1243,7 +1239,7 @@ class WalletNode:
         self.log.info("Secondary peer syncing")
         # In this case we will not rollback so it's OK to check some older updates as well, to ensure
         # that no recent transactions are being hidden.
-        self._secondary_peer_sync_task = asyncio.create_task(
+        self._secondary_peer_sync_task = create_referenced_task(
             self.long_sync(new_peak_hb.height, peer, 0, rollback=False)
         )
 
@@ -1263,10 +1259,10 @@ class WalletNode:
                 # Edge case, this happens when the peak < WEIGHT_PROOF_RECENT_BLOCKS
                 # we still want to subscribe for all phs and coins.
                 # (Hints are not in filter)
-                all_coin_ids: List[bytes32] = await self.get_coin_ids_to_subscribe()
-                phs: List[bytes32] = await self.get_puzzle_hashes_to_subscribe()
-                ph_updates: List[CoinState] = await subscribe_to_phs(phs, peer, min_height_for_subscriptions)
-                coin_updates: List[CoinState] = await subscribe_to_coin_updates(
+                all_coin_ids: list[bytes32] = await self.get_coin_ids_to_subscribe()
+                phs: list[bytes32] = await self.get_puzzle_hashes_to_subscribe()
+                ph_updates: list[CoinState] = await subscribe_to_phs(phs, peer, min_height_for_subscriptions)
+                coin_updates: list[CoinState] = await subscribe_to_coin_updates(
                     all_coin_ids, peer, min_height_for_subscriptions
                 )
                 success = await self.add_states_from_peer(
@@ -1373,7 +1369,7 @@ class WalletNode:
 
         return get_wp_fork_point(self.constants, old_proof, weight_proof)
 
-    async def get_puzzle_hashes_to_subscribe(self) -> List[bytes32]:
+    async def get_puzzle_hashes_to_subscribe(self) -> list[bytes32]:
         all_puzzle_hashes = await self.wallet_state_manager.puzzle_store.get_all_puzzle_hashes(1)
         # Get all phs from interested store
         interested_puzzle_hashes = [
@@ -1382,7 +1378,7 @@ class WalletNode:
         all_puzzle_hashes.update(interested_puzzle_hashes)
         return list(all_puzzle_hashes)
 
-    async def get_coin_ids_to_subscribe(self) -> List[bytes32]:
+    async def get_coin_ids_to_subscribe(self) -> list[bytes32]:
         coin_ids = await self.wallet_state_manager.trade_manager.get_coins_of_interest()
         coin_ids.update(await self.wallet_state_manager.interested_store.get_interested_coin_ids())
         return list(coin_ids)
@@ -1475,7 +1471,7 @@ class WalletNode:
                 # Peer is telling us that coin that was previously known to be spent is not spent anymore
                 # Check old state
 
-                spent_state_blocks: Optional[List[HeaderBlock]] = await request_header_blocks(
+                spent_state_blocks: Optional[list[HeaderBlock]] = await request_header_blocks(
                     peer, current.spent_block_height, current.spent_block_height
                 )
                 if spent_state_blocks is None:
@@ -1601,7 +1597,7 @@ class WalletNode:
             return False
         all_peers_c = self.server.get_connections(NodeType.FULL_NODE)
         all_peers = [(con, self.is_trusted(con)) for con in all_peers_c]
-        blocks: Optional[List[HeaderBlock]] = await fetch_header_blocks_in_range(
+        blocks: Optional[list[HeaderBlock]] = await fetch_header_blocks_in_range(
             start, end, peer_request_cache, all_peers
         )
         if blocks is None:
@@ -1618,9 +1614,9 @@ class WalletNode:
             if last != weight_proof.sub_epochs[inserted].reward_chain_hash:
                 self.log.error("Failed validation 4")
                 return False
-        pk_m_sig: List[Tuple[G1Element, bytes32, G2Element]] = []
-        sigs_to_cache: List[HeaderBlock] = []
-        blocks_to_cache: List[Tuple[bytes32, uint32]] = []
+        pk_m_sig: list[tuple[G1Element, bytes32, G2Element]] = []
+        sigs_to_cache: list[HeaderBlock] = []
+        blocks_to_cache: list[tuple[bytes32, uint32]] = []
 
         signatures_to_validate: int = 30
         for idx in range(len(blocks)):
@@ -1684,10 +1680,10 @@ class WalletNode:
         return True
 
     async def get_coin_state(
-        self, coin_names: List[bytes32], peer: WSChiaConnection, fork_height: Optional[uint32] = None
-    ) -> List[CoinState]:
+        self, coin_names: list[bytes32], peer: WSChiaConnection, fork_height: Optional[uint32] = None
+    ) -> list[CoinState]:
         msg = RegisterForCoinUpdates(coin_names, uint32(0))
-        coin_state: Optional[RespondToCoinUpdates] = await peer.call_api(FullNodeAPI.register_interest_in_coin, msg)
+        coin_state: Optional[RespondToCoinUpdates] = await peer.call_api(FullNodeAPI.register_for_coin_updates, msg)
         if coin_state is None or not isinstance(coin_state, RespondToCoinUpdates):
             raise PeerRequestException(f"Was not able to get states for {coin_names}")
 
@@ -1709,7 +1705,7 @@ class WalletNode:
 
     async def fetch_children(
         self, coin_name: bytes32, peer: WSChiaConnection, fork_height: Optional[uint32] = None
-    ) -> List[CoinState]:
+    ) -> list[CoinState]:
         response: Optional[RespondChildren] = await peer.call_api(
             FullNodeAPI.request_children, RequestChildren(coin_name)
         )
@@ -1747,7 +1743,7 @@ class WalletNode:
         pending_change = await wallet.get_pending_change_balance()
         max_send_amount = await wallet.get_max_send_amount(unspent_records)
 
-        unconfirmed_removals: Dict[bytes32, Coin] = await wallet.wallet_state_manager.unconfirmed_removals_for_wallet(
+        unconfirmed_removals: dict[bytes32, Coin] = await wallet.wallet_state_manager.unconfirmed_removals_for_wallet(
             wallet_id
         )
         self._balance_cache[wallet_id] = Balance(