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

chia/pools/pool_wallet.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import dataclasses
 import logging
 import time
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Set, Tuple, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chia_rs import G1Element, G2Element, PrivateKey
 from typing_extensions import final
@@ -80,7 +80,7 @@ class PoolWallet:
     next_transaction_fee: uint64 = uint64(0)
     next_tx_config: TXConfig = DEFAULT_TX_CONFIG
     target_state: Optional[PoolState] = None
-    _owner_sk_and_index: Optional[Tuple[PrivateKey, uint32]] = None
+    _owner_sk_and_index: Optional[tuple[PrivateKey, uint32]] = None
 
     """
     From the user's perspective, this is not a wallet at all, but a way to control
@@ -137,7 +137,7 @@ class PoolWallet:
     @classmethod
     def _verify_self_pooled(cls, state: PoolState) -> Optional[str]:
         err = ""
-        if state.pool_url not in [None, ""]:
+        if state.pool_url not in {None, ""}:
             err += " Unneeded pool_url for self-pooling"
 
         if state.relative_lock_height != 0:
@@ -159,7 +159,7 @@ class PoolWallet:
                 f"is greater than recommended maximum ({cls.MAXIMUM_RELATIVE_LOCK_HEIGHT})"
             )
 
-        if state.pool_url in [None, ""]:
+        if state.pool_url in {None, ""}:
             err += " Empty pool url in pooling state"
         return err
 
@@ -177,10 +177,7 @@ class PoolWallet:
 
         if state.state == PoolSingletonState.SELF_POOLING.value:
             return cls._verify_self_pooled(state)
-        elif (
-            state.state == PoolSingletonState.FARMING_TO_POOL.value
-            or state.state == PoolSingletonState.LEAVING_POOL.value
-        ):
+        elif state.state in {PoolSingletonState.FARMING_TO_POOL.value, PoolSingletonState.LEAVING_POOL.value}:
             return cls._verify_pooling_state(state)
         else:
             return "Internal Error"
@@ -191,12 +188,12 @@ class PoolWallet:
         if err:
             raise ValueError(f"Invalid internal Pool State: {err}: {initial_target_state}")
 
-    async def get_spend_history(self) -> List[Tuple[uint32, CoinSpend]]:
+    async def get_spend_history(self) -> list[tuple[uint32, CoinSpend]]:
         return await self.wallet_state_manager.pool_store.get_spends_for_wallet(self.wallet_id)
 
     async def get_current_state(self) -> PoolWalletInfo:
-        history: List[Tuple[uint32, CoinSpend]] = await self.get_spend_history()
-        all_spends: List[CoinSpend] = [cs for _, cs in history]
+        history: list[tuple[uint32, CoinSpend]] = await self.get_spend_history()
+        all_spends: list[CoinSpend] = [cs for _, cs in history]
 
         # We must have at least the launcher spend
         assert len(all_spends) >= 1
@@ -228,21 +225,29 @@ class PoolWallet:
             last_singleton_spend_height,
         )
 
-    async def get_unconfirmed_transactions(self) -> List[TransactionRecord]:
+    async def get_unconfirmed_transactions(self) -> list[TransactionRecord]:
         return await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(self.wallet_id)
 
-    async def get_tip(self) -> Tuple[uint32, CoinSpend]:
+    async def get_tip(self) -> tuple[uint32, CoinSpend]:
         return (await self.wallet_state_manager.pool_store.get_spends_for_wallet(self.wallet_id))[-1]
 
     async def update_pool_config(self) -> None:
         current_state: PoolWalletInfo = await self.get_current_state()
-        pool_config_list: List[PoolWalletConfig] = load_pool_config(self.wallet_state_manager.root_path)
-        pool_config_dict: Dict[bytes32, PoolWalletConfig] = {c.launcher_id: c for c in pool_config_list}
+        pool_config_list: list[PoolWalletConfig] = load_pool_config(self.wallet_state_manager.root_path)
+        pool_config_dict: dict[bytes32, PoolWalletConfig] = {c.launcher_id: c for c in pool_config_list}
         existing_config: Optional[PoolWalletConfig] = pool_config_dict.get(current_state.launcher_id, None)
         payout_instructions: str = existing_config.payout_instructions if existing_config is not None else ""
 
         if len(payout_instructions) == 0:
-            payout_instructions = (await self.standard_wallet.get_new_puzzlehash()).hex()
+            reuse_puzhash_config = self.wallet_state_manager.config.get("reuse_public_key_for_change", None)
+            if reuse_puzhash_config is None:
+                reuse_puzhash = False
+            else:
+                reuse_puzhash = reuse_puzhash_config.get(
+                    str(self.wallet_state_manager.root_pubkey.get_fingerprint()), False
+                )
+
+            payout_instructions = (await self.standard_wallet.get_puzzle_hash(new=not reuse_puzhash)).hex()
             self.log.info(f"New config entry. Generated payout_instructions puzzle hash: {payout_instructions}")
 
         new_config: PoolWalletConfig = PoolWalletConfig(
@@ -262,7 +267,7 @@ class PoolWallet:
         The DB must be committed after calling this method. All validation should be done here. Returns True iff
         the spend is a valid transition spend for the singleton, False otherwise.
         """
-        tip: Tuple[uint32, CoinSpend] = await self.get_tip()
+        tip: tuple[uint32, CoinSpend] = await self.get_tip()
         tip_spend = tip[1]
 
         tip_coin: Optional[Coin] = get_most_recent_singleton_coin_from_coin_spend(tip_spend)
@@ -270,7 +275,7 @@ class PoolWallet:
         spent_coin_name: bytes32 = tip_coin.name()
 
         if spent_coin_name != new_state.coin.name():
-            history: List[Tuple[uint32, CoinSpend]] = await self.get_spend_history()
+            history: list[tuple[uint32, CoinSpend]] = await self.get_spend_history()
             if new_state.coin.name() in [sp.coin.name() for _, sp in history]:
                 self.log.info(f"Already have state transition: {new_state.coin.name().hex()}")
             else:
@@ -304,7 +309,7 @@ class PoolWallet:
         Returns True if the wallet should be removed.
         """
         try:
-            history: List[Tuple[uint32, CoinSpend]] = await self.wallet_state_manager.pool_store.get_spends_for_wallet(
+            history: list[tuple[uint32, CoinSpend]] = await self.wallet_state_manager.pool_store.get_spends_for_wallet(
                 self.wallet_id
             )
             prev_state: PoolWalletInfo = await self.get_current_state()
@@ -326,7 +331,7 @@ class PoolWallet:
         wallet_state_manager: Any,
         wallet: Wallet,
         launcher_coin_id: bytes32,
-        block_spends: List[CoinSpend],
+        block_spends: list[CoinSpend],
         block_height: uint32,
         *,
         name: Optional[str] = None,
@@ -391,8 +396,8 @@ class PoolWallet:
         fee: uint64 = uint64(0),
         p2_singleton_delay_time: Optional[uint64] = None,
         p2_singleton_delayed_ph: Optional[bytes32] = None,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
-    ) -> Tuple[bytes32, bytes32]:
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> tuple[bytes32, bytes32]:
         """
         A "plot NFT", or pool wallet, represents the idea of a set of plots that all pay to
         the same pooling puzzle. This puzzle is a `chia singleton` that is
@@ -405,7 +410,9 @@ class PoolWallet:
         standard_wallet = main_wallet
 
         if p2_singleton_delayed_ph is None:
-            p2_singleton_delayed_ph = await main_wallet.get_new_puzzlehash()
+            p2_singleton_delayed_ph = await main_wallet.get_puzzle_hash(
+                new=not action_scope.config.tx_config.reuse_puzhash
+            )
         if p2_singleton_delay_time is None:
             p2_singleton_delay_time = uint64(604800)
 
@@ -414,12 +421,12 @@ class PoolWallet:
         if balance < PoolWallet.MINIMUM_INITIAL_BALANCE:
             raise ValueError("Not enough balance in main wallet to create a managed plotting pool.")
         if balance < PoolWallet.MINIMUM_INITIAL_BALANCE + fee:
-            raise ValueError("Not enough balance in main wallet to create a managed plotting pool with fee {fee}.")
+            raise ValueError(f"Not enough balance in main wallet to create a managed plotting pool with fee {fee}.")
 
         # Verify Parameters - raise if invalid
         PoolWallet._verify_initial_target_state(initial_target_state)
 
-        singleton_puzzle_hash, launcher_coin_id = await PoolWallet.generate_launcher_spend(
+        _singleton_puzzle_hash, launcher_coin_id = await PoolWallet.generate_launcher_spend(
             standard_wallet,
             uint64(1),
             fee,
@@ -437,7 +444,7 @@ class PoolWallet:
 
         return p2_singleton_puzzle_hash, launcher_coin_id
 
-    async def _get_owner_key_cache(self) -> Tuple[PrivateKey, uint32]:
+    async def _get_owner_key_cache(self) -> tuple[PrivateKey, uint32]:
         if self._owner_sk_and_index is None:
             self._owner_sk_and_index = find_owner_sk(
                 [self.wallet_state_manager.get_master_private_key()],
@@ -453,7 +460,7 @@ class PoolWallet:
         self,
         fee: uint64,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         await self.standard_wallet.generate_signed_transaction(
             uint64(0),
@@ -514,19 +521,19 @@ class PoolWallet:
         assert new_inner_puzzle != inner_puzzle
         if is_pool_member_inner_puzzle(inner_puzzle):
             (
-                inner_f,
-                target_puzzle_hash,
-                p2_singleton_hash,
-                pubkey_as_program,
-                pool_reward_prefix,
-                escape_puzzle_hash,
+                _inner_f,
+                _target_puzzle_hash,
+                _p2_singleton_hash,
+                _pubkey_as_program,
+                _pool_reward_prefix,
+                _escape_puzzle_hash,
             ) = uncurry_pool_member_inner_puzzle(inner_puzzle)
         elif is_pool_waitingroom_inner_puzzle(inner_puzzle):
             (
-                target_puzzle_hash,  # payout_puzzle_hash
-                relative_lock_height,
-                pubkey_as_program,
-                p2_singleton_hash,
+                _target_puzzle_hash,  # payout_puzzle_hash
+                _relative_lock_height,
+                _pubkey_as_program,
+                _p2_singleton_hash,
             ) = uncurry_pool_waitingroom_inner_puzzle(inner_puzzle)
         else:
             raise RuntimeError("Invalid state")
@@ -570,13 +577,13 @@ class PoolWallet:
         delay_time: uint64,
         delay_ph: bytes32,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
-    ) -> Tuple[bytes32, bytes32]:
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> tuple[bytes32, bytes32]:
         """
         Creates the initial singleton, which includes spending an origin coin, the launcher, and creating a singleton
         with the "pooling" inner state, which can be either self pooling or using a pool
         """
-        coins: Set[Coin] = await standard_wallet.select_coins(uint64(amount + fee), action_scope)
+        coins: set[Coin] = await standard_wallet.select_coins(uint64(amount + fee), action_scope)
         if coins is None:
             raise ValueError("Not enough coins to create pool wallet")
 
@@ -663,7 +670,7 @@ class PoolWallet:
             msg = f"Asked to change to current state. Target = {target_state}"
             self.log.info(msg)
             raise ValueError(msg)
-        elif current_state.current.state in [SELF_POOLING.value, LEAVING_POOL.value]:
+        elif current_state.current.state in {SELF_POOLING.value, LEAVING_POOL.value}:
             total_fee = fee
         elif current_state.current.state == FARMING_TO_POOL.value:
             total_fee = uint64(fee * 2)
@@ -674,7 +681,7 @@ class PoolWallet:
             )
         PoolWallet._verify_initial_target_state(target_state)
         if current_state.current.state == LEAVING_POOL.value:
-            history: List[Tuple[uint32, CoinSpend]] = await self.get_spend_history()
+            history: list[tuple[uint32, CoinSpend]] = await self.get_spend_history()
             last_height: uint32 = history[-1][0]
             if (
                 await self.wallet_state_manager.blockchain.get_finished_sync_up_to()
@@ -711,7 +718,7 @@ class PoolWallet:
 
         if current_state.current.state == LEAVING_POOL.value:
             total_fee = fee
-            history: List[Tuple[uint32, CoinSpend]] = await self.get_spend_history()
+            history: list[tuple[uint32, CoinSpend]] = await self.get_spend_history()
             last_height: uint32 = history[-1][0]
             if (
                 await self.wallet_state_manager.blockchain.get_finished_sync_up_to()
@@ -746,21 +753,21 @@ class PoolWallet:
         unspent_coin_records = await self.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(self.wallet_id)
         if len(unspent_coin_records) == 0:
             raise ValueError("Nothing to claim, no transactions to p2_singleton_puzzle_hash")
-        farming_rewards: List[TransactionRecord] = await self.wallet_state_manager.tx_store.get_farming_rewards()
-        coin_to_height_farmed: Dict[Coin, uint32] = {}
+        farming_rewards: list[TransactionRecord] = await self.wallet_state_manager.tx_store.get_farming_rewards()
+        coin_to_height_farmed: dict[Coin, uint32] = {}
         for tx_record in farming_rewards:
             height_farmed: Optional[uint32] = tx_record.height_farmed(
                 self.wallet_state_manager.constants.GENESIS_CHALLENGE
             )
             assert height_farmed is not None
             coin_to_height_farmed[tx_record.additions[0]] = height_farmed
-        history: List[Tuple[uint32, CoinSpend]] = await self.get_spend_history()
+        history: list[tuple[uint32, CoinSpend]] = await self.get_spend_history()
         assert len(history) > 0
         delayed_seconds, delayed_puzhash = get_delayed_puz_info_from_launcher_spend(history[0][1])
         current_state: PoolWalletInfo = await self.get_current_state()
         last_solution: CoinSpend = history[-1][1]
 
-        all_spends: List[CoinSpend] = []
+        all_spends: list[CoinSpend] = []
         total_amount = 0
 
         # The coins being claimed are gathered into the `SpendBundle`, :absorb_spend:
@@ -778,7 +785,7 @@ class PoolWallet:
                 self.log.info(f"pool wallet truncating absorb to {max_spends_in_tx} spends to fit into block")
                 print(f"pool wallet truncating absorb to {max_spends_in_tx} spends to fit into block")
                 break
-            absorb_spend: List[CoinSpend] = create_absorb_spend(
+            absorb_spend: list[CoinSpend] = create_absorb_spend(
                 last_solution,
                 current_state.current,
                 current_state.launcher_coin,
@@ -821,7 +828,7 @@ class PoolWallet:
                     confirmed=False,
                     sent=uint32(0),
                     spend_bundle=claim_spend,
-                    additions=claim_spend.additions(),
+                    additions=[add for add in claim_spend.additions() if add.amount == last_solution.coin.amount],
                     removals=claim_spend.removals(),
                     wallet_id=uint32(self.wallet_id),
                     sent_to=[],
@@ -846,16 +853,16 @@ class PoolWallet:
             raise ValueError(f"Internal error. Pool wallet {self.wallet_id} state: {pool_wallet_info.current}")
 
         if (
-            self.target_state.state in [FARMING_TO_POOL.value, SELF_POOLING.value]
+            self.target_state.state in {FARMING_TO_POOL.value, SELF_POOLING.value}
             and pool_wallet_info.current.state == LEAVING_POOL.value
         ):
             leave_height = tip_height + pool_wallet_info.current.relative_lock_height
 
             # Add some buffer (+2) to reduce chances of a reorg
             if peak_height > leave_height + 2:
-                unconfirmed: List[TransactionRecord] = (
-                    await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(self.wallet_id)
-                )
+                unconfirmed: list[
+                    TransactionRecord
+                ] = await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(self.wallet_id)
                 next_tip: Optional[Coin] = get_most_recent_singleton_coin_from_coin_spend(tip_spend)
                 assert next_tip is not None
 
@@ -879,7 +886,7 @@ class PoolWallet:
                     await self.generate_travel_transactions(self.next_transaction_fee, action_scope)
 
     async def have_unconfirmed_transaction(self) -> bool:
-        unconfirmed: List[TransactionRecord] = await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(
+        unconfirmed: list[TransactionRecord] = await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(
             self.wallet_id
         )
         return len(unconfirmed) > 0
@@ -887,7 +894,7 @@ class PoolWallet:
     async def get_confirmed_balance(self, _: Optional[object] = None) -> uint128:
         amount: uint128 = uint128(0)
         if (await self.get_current_state()).current.state == SELF_POOLING.value:
-            unspent_coin_records: List[WalletCoinRecord] = list(
+            unspent_coin_records: list[WalletCoinRecord] = list(
                 await self.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(self.wallet_id)
             )
             for record in unspent_coin_records:
@@ -904,13 +911,13 @@ class PoolWallet:
     async def get_pending_change_balance(self) -> uint64:
         return uint64(0)
 
-    async def get_max_send_amount(self, records: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128:
         return uint128(0)
 
     async def coin_added(self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: Optional[object]) -> None:
         pass
 
-    async def select_coins(self, amount: uint64, action_scope: WalletActionScope) -> Set[Coin]:
+    async def select_coins(self, amount: uint64, action_scope: WalletActionScope) -> set[Coin]:
         raise RuntimeError("PoolWallet does not support select_coins()")
 
     def require_derivation_paths(self) -> bool:

chia/pools/pool_wallet_info.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import IntEnum
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from chia_rs import G1Element
 
@@ -62,7 +62,7 @@ class PoolState(Streamable):
 
 
 def initial_pool_state_from_dict(
-    state_dict: Dict[str, Any],
+    state_dict: dict[str, Any],
     owner_pubkey: G1Element,
     owner_puzzle_hash: bytes32,
 ) -> PoolState:
@@ -93,7 +93,7 @@ def create_pool_state(
     relative_lock_height: uint32,
 ) -> PoolState:
     if state not in {s.value for s in PoolSingletonState}:
-        raise AssertionError("state {state} is not a valid PoolSingletonState,")
+        raise AssertionError(f"state {state} is not a valid PoolSingletonState,")
     ps = PoolState(
         POOL_PROTOCOL_VERSION, uint8(state), target_puzzle_hash, owner_pubkey, pool_url, relative_lock_height
     )

chia/protocols/full_node_protocol.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
@@ -90,7 +90,7 @@ class RequestBlocks(Streamable):
 class RespondBlocks(Streamable):
     start_height: uint32
     end_height: uint32
-    blocks: List[FullBlock]
+    blocks: list[FullBlock]
 
 
 @streamable
@@ -216,4 +216,4 @@ class RequestPeers(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RespondPeers(Streamable):
-    peer_list: List[TimestampedPeerInfo]
+    peer_list: list[TimestampedPeerInfo]

chia/protocols/harvester_protocol.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import IntEnum
-from typing import List, Optional, Tuple
+from typing import Optional
 
 from chia_rs import G1Element, G2Element
 
@@ -29,8 +29,8 @@ class PoolDifficulty(Streamable):
 @streamable
 @dataclass(frozen=True)
 class HarvesterHandshake(Streamable):
-    farmer_public_keys: List[G1Element]
-    pool_public_keys: List[G1Element]
+    farmer_public_keys: list[G1Element]
+    pool_public_keys: list[G1Element]
 
 
 @streamable
@@ -41,7 +41,7 @@ class NewSignagePointHarvester(Streamable):
     sub_slot_iters: uint64
     signage_point_index: uint8
     sp_hash: bytes32
-    pool_difficulties: List[PoolDifficulty]
+    pool_difficulties: list[PoolDifficulty]
     filter_prefix_bits: uint8
 
 
@@ -90,9 +90,9 @@ class RequestSignatures(Streamable):
     plot_identifier: str
     challenge_hash: bytes32
     sp_hash: bytes32
-    messages: List[bytes32]
+    messages: list[bytes32]
     # This, and rc_block_unfinished are only set when using a third-party harvester (see CHIP-22)
-    message_data: Optional[List[Optional[SignatureRequestSourceData]]]
+    message_data: Optional[list[Optional[SignatureRequestSourceData]]]
     rc_block_unfinished: Optional[RewardChainBlockUnfinished]
 
 
@@ -104,7 +104,7 @@ class RespondSignatures(Streamable):
     sp_hash: bytes32
     local_pk: G1Element
     farmer_pk: G1Element
-    message_signatures: List[Tuple[bytes32, G2Element]]
+    message_signatures: list[tuple[bytes32, G2Element]]
     include_source_signature_data: bool
     farmer_reward_address_override: Optional[bytes32]
 
@@ -132,9 +132,9 @@ class RequestPlots(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RespondPlots(Streamable):
-    plots: List[Plot]
-    failed_to_open_filenames: List[str]
-    no_key_filenames: List[str]
+    plots: list[Plot]
+    failed_to_open_filenames: list[str]
+    no_key_filenames: list[str]
 
 
 @streamable
@@ -166,7 +166,7 @@ class PlotSyncStart(Streamable):
 @dataclass(frozen=True)
 class PlotSyncPathList(Streamable):
     identifier: PlotSyncIdentifier
-    data: List[str]
+    data: list[str]
     final: bool
 
     def __str__(self) -> str:
@@ -177,7 +177,7 @@ class PlotSyncPathList(Streamable):
 @dataclass(frozen=True)
 class PlotSyncPlotList(Streamable):
     identifier: PlotSyncIdentifier
-    data: List[Plot]
+    data: list[Plot]
     final: bool
 
     def __str__(self) -> str:

chia/protocols/introducer_protocol.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List
 
 from chia.types.peer_info import TimestampedPeerInfo
 from chia.util.streamable import Streamable, streamable
@@ -23,4 +22,4 @@ class RequestPeersIntroducer(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RespondPeersIntroducer(Streamable):
-    peer_list: List[TimestampedPeerInfo]
+    peer_list: list[TimestampedPeerInfo]

chia/protocols/protocol_message_types.py

@@ -100,10 +100,10 @@ class ProtocolMessageTypes(Enum):
 
     # More wallet protocol
     coin_state_update = 69
-    register_interest_in_puzzle_hash = 70
-    respond_to_ph_update = 71
-    register_interest_in_coin = 72
-    respond_to_coin_update = 73
+    register_for_ph_updates = 70
+    respond_to_ph_updates = 71
+    register_for_coin_updates = 72
+    respond_to_coin_updates = 73
     request_children = 74
     respond_children = 75
     request_ses_hashes = 76

chia/protocols/protocol_state_machine.py

@@ -41,8 +41,8 @@ VALID_REPLY_MESSAGE_MAP = {
     pmt.request_compact_vdf: [pmt.respond_compact_vdf],
     pmt.request_peers: [pmt.respond_peers],
     pmt.request_header_blocks: [pmt.respond_header_blocks, pmt.reject_header_blocks, pmt.reject_block_headers],
-    pmt.register_interest_in_puzzle_hash: [pmt.respond_to_ph_update],
-    pmt.register_interest_in_coin: [pmt.respond_to_coin_update],
+    pmt.register_for_ph_updates: [pmt.respond_to_ph_updates],
+    pmt.register_for_coin_updates: [pmt.respond_to_coin_updates],
     pmt.request_children: [pmt.respond_children],
     pmt.request_ses_hashes: [pmt.respond_ses_hashes],
     pmt.request_block_headers: [pmt.respond_block_headers, pmt.reject_block_headers, pmt.reject_header_blocks],

chia/protocols/protocol_timing.py

@@ -5,3 +5,4 @@ INVALID_PROTOCOL_BAN_SECONDS = 10
 API_EXCEPTION_BAN_SECONDS = 10
 INTERNAL_PROTOCOL_ERROR_BAN_SECONDS = 10  # Don't flap if our client is at fault
 CONSENSUS_ERROR_BAN_SECONDS = 600
+RATE_LIMITER_BAN_SECONDS = 300

chia/protocols/shared_protocol.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import IntEnum
-from typing import List, Optional, Tuple
+from typing import Optional
 
 from chia.server.outbound_message import NodeType
 from chia.util.ints import int16, uint8, uint16
@@ -47,7 +47,7 @@ class Capability(IntEnum):
 
 # These are the default capabilities used in all outgoing handshakes.
 # "1" means the capability is supported and enabled.
-_capabilities: List[Tuple[uint16, str]] = [
+_capabilities: list[tuple[uint16, str]] = [
     (uint16(Capability.BASE.value), "1"),
     (uint16(Capability.BLOCK_HEADERS.value), "1"),
     (uint16(Capability.RATE_LIMITS_V2.value), "1"),
@@ -75,7 +75,7 @@ class Handshake(Streamable):
     software_version: str
     server_port: uint16
     node_type: uint8
-    capabilities: List[Tuple[uint16, str]]
+    capabilities: list[tuple[uint16, str]]
 
 
 @streamable

chia/protocols/timelord_protocol.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List, Optional, Tuple
+from typing import Optional
 
 from chia.types.blockchain_format.foliage import Foliage
 from chia.types.blockchain_format.reward_chain_block import RewardChainBlock, RewardChainBlockUnfinished
@@ -28,7 +28,7 @@ class NewPeakTimelord(Streamable):
     sub_epoch_summary: Optional[
         SubEpochSummary
     ]  # If NewPeak is the last slot in epoch, the next slot should include this
-    previous_reward_challenges: List[Tuple[bytes32, uint128]]
+    previous_reward_challenges: list[tuple[bytes32, uint128]]
     last_challenge_sb_or_eos_total_iters: uint128
     passes_ses_height_but_not_yet_included: bool