chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5__py3-none-any.whl

chia/harvester/harvester_api.py

@@ -6,23 +6,26 @@ import time
 from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
-from chia_rs import AugSchemeMPL, G1Element, G2Element
+from chia_rs import AugSchemeMPL, G1Element, G2Element, PlotSize, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
-from chia.consensus.pot_iterations import calculate_iterations_quality, calculate_sp_interval_iters
+from chia.consensus.pot_iterations import (
+    calculate_iterations_quality,
+    calculate_sp_interval_iters,
+)
 from chia.harvester.harvester import Harvester
 from chia.plotting.util import PlotInfo, parse_plot_info
 from chia.protocols import harvester_protocol
 from chia.protocols.farmer_protocol import FarmingInfo
 from chia.protocols.harvester_protocol import Plot, PlotSyncResponse
+from chia.protocols.outbound_message import Message, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.server.api_protocol import ApiMetadata
-from chia.server.outbound_message import Message, make_msg
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.proof_of_space import (
-    ProofOfSpace,
     calculate_pos_challenge,
+    calculate_prefix_bits,
     generate_plot_public_key,
     passes_plot_filter,
 )
@@ -144,12 +147,15 @@ class HarvesterAPI:
 
                     # Found proofs of space (on average 1 is expected per plot)
                     for index, quality_str in enumerate(quality_strings):
+                        # TODO: todo_v2_plots
                         required_iters: uint64 = calculate_iterations_quality(
-                            self.harvester.constants.DIFFICULTY_CONSTANT_FACTOR,
+                            self.harvester.constants,
                             quality_str,
-                            plot_info.prover.get_size(),
+                            PlotSize.make_v1(plot_info.prover.get_size()),
                             difficulty,
                             new_challenge.sp_hash,
+                            sub_slot_iters,
+                            new_challenge.last_tx_height,
                         )
                         sp_interval_iters = calculate_sp_interval_iters(self.harvester.constants, sub_slot_iters)
                         if required_iters < sp_interval_iters:
@@ -243,8 +249,17 @@ class HarvesterAPI:
                 # Passes the plot filter (does not check sp filter yet though, since we have not reached sp)
                 # This is being executed at the beginning of the slot
                 total += 1
+
+                # TODO: todo_v2_plots support v2 plots in PlotManager
+                filter_prefix_bits = uint8(
+                    calculate_prefix_bits(
+                        self.harvester.constants,
+                        new_challenge.peak_height,
+                        PlotSize.make_v1(try_plot_info.prover.get_size()),
+                    )
+                )
                 if passes_plot_filter(
-                    new_challenge.filter_prefix_bits,
+                    filter_prefix_bits,
                     try_plot_info.prover.get_id(),
                     new_challenge.challenge_hash,
                     new_challenge.sp_hash,

chia/introducer/introducer.py

@@ -11,9 +11,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 import dns.asyncresolver
 from chia_rs.sized_ints import uint16, uint64
 
+from chia.protocols.outbound_message import NodeType
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
 from chia.server.introducer_peers import VettedPeer
-from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import TimestampedPeerInfo

chia/introducer/introducer_api.py

@@ -7,10 +7,10 @@ from chia_rs.sized_ints import uint64
 
 from chia.introducer.introducer import Introducer
 from chia.protocols.introducer_protocol import RequestPeersIntroducer, RespondPeersIntroducer
+from chia.protocols.outbound_message import Message, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.rpc.rpc_server import StateChangedProtocol
 from chia.server.api_protocol import ApiMetadata
-from chia.server.outbound_message import Message, make_msg
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import TimestampedPeerInfo
 

chia/plot_sync/exceptions.py

@@ -6,7 +6,7 @@ from chia_rs.sized_ints import uint64
 
 from chia.plot_sync.util import ErrorCodes, State
 from chia.protocols.harvester_protocol import PlotSyncIdentifier
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
 
 
 class PlotSyncException(Exception):

chia/plot_sync/receiver.py

@@ -32,8 +32,8 @@ from chia.protocols.harvester_protocol import (
     PlotSyncResponse,
     PlotSyncStart,
 )
+from chia.protocols.outbound_message import make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.server.outbound_message import make_msg
 from chia.server.ws_connection import WSChiaConnection
 
 log = logging.getLogger(__name__)

chia/plot_sync/sender.py

@@ -25,8 +25,8 @@ from chia.protocols.harvester_protocol import (
     PlotSyncResponse,
     PlotSyncStart,
 )
+from chia.protocols.outbound_message import NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.server.outbound_message import NodeType, make_msg
 from chia.server.ws_connection import WSChiaConnection
 from chia.util.batches import to_batches
 from chia.util.task_referencer import create_referenced_task
@@ -125,7 +125,7 @@ class Sender:
             if not self._plot_manager.initial_refresh() or self._sync_id != 0:
                 self._reset()
         else:
-            raise AlreadyStartedError()
+            raise AlreadyStartedError
 
     def stop(self) -> None:
         self._stop_requested = True

chia/pools/pool_puzzles.py

@@ -11,10 +11,9 @@ from chia_puzzles_py.programs import (
     POOL_WAITINGROOM_INNERPUZ,
     POOL_WAITINGROOM_INNERPUZ_HASH,
 )
-from chia_rs import G1Element
+from chia_rs import CoinSpend, G1Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
-from clvm.casts import int_to_bytes
 
 from chia.consensus.block_rewards import calculate_pool_reward
 from chia.consensus.coinbase import pool_parent_id
@@ -22,13 +21,15 @@ from chia.pools.pool_wallet_info import LEAVING_POOL, SELF_POOLING, PoolState
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.coin_spend import CoinSpend, compute_additions
+from chia.types.coin_spend import make_spend
+from chia.util.casts import int_to_bytes
 from chia.wallet.puzzles.singleton_top_layer import (
     SINGLETON_LAUNCHER_HASH,
     SINGLETON_MOD,
     SINGLETON_MOD_HASH,
     puzzle_for_singleton,
 )
+from chia.wallet.util.compute_additions import compute_additions
 from chia.wallet.util.curry_and_treehash import calculate_hash_of_quoted_mod_hash, curry_and_treehash, shatree_atom
 
 log = logging.getLogger(__name__)
@@ -240,10 +241,10 @@ def create_travel_spend(
     full_puzzle: Program = create_full_puzzle(inner_puzzle, launcher_coin.name())
 
     return (
-        CoinSpend(
+        make_spend(
             current_singleton,
-            SerializedProgram.from_program(full_puzzle),
-            SerializedProgram.from_program(full_solution),
+            full_puzzle,
+            full_solution,
         ),
         inner_puzzle,
     )
@@ -287,22 +288,16 @@ def create_absorb_spend(
                 last_coin_spend.coin.amount,
             ]
         )
-    full_solution: SerializedProgram = SerializedProgram.from_program(
-        Program.to([parent_info, last_coin_spend.coin.amount, inner_sol])
-    )
-    full_puzzle: SerializedProgram = SerializedProgram.from_program(
-        create_full_puzzle(inner_puzzle, launcher_coin.name())
-    )
+    full_solution: SerializedProgram = SerializedProgram.to([parent_info, last_coin_spend.coin.amount, inner_sol])
+    full_puzzle: SerializedProgram = create_full_puzzle(inner_puzzle, launcher_coin.name()).to_serialized()
     assert coin.puzzle_hash == full_puzzle.get_tree_hash()
 
     reward_parent: bytes32 = pool_parent_id(height, genesis_challenge)
-    p2_singleton_puzzle: SerializedProgram = SerializedProgram.from_program(
-        create_p2_singleton_puzzle(SINGLETON_MOD_HASH, launcher_coin.name(), delay_time, delay_ph)
-    )
+    p2_singleton_puzzle = create_p2_singleton_puzzle(
+        SINGLETON_MOD_HASH, launcher_coin.name(), delay_time, delay_ph
+    ).to_serialized()
     reward_coin: Coin = Coin(reward_parent, p2_singleton_puzzle.get_tree_hash(), reward_amount)
-    p2_singleton_solution: SerializedProgram = SerializedProgram.from_program(
-        Program.to([inner_puzzle.get_tree_hash(), reward_coin.name()])
-    )
+    p2_singleton_solution = SerializedProgram.to([inner_puzzle.get_tree_hash(), reward_coin.name()])
     assert p2_singleton_puzzle.get_tree_hash() == reward_coin.puzzle_hash
     assert full_puzzle.get_tree_hash() == coin.puzzle_hash
     assert get_inner_puzzle_from_puzzle(Program.from_bytes(bytes(full_puzzle))) is not None

chia/pools/pool_wallet.py

@@ -5,7 +5,7 @@ import logging
 import time
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
-from chia_rs import G1Element, G2Element, PrivateKey
+from chia_rs import CoinSpend, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64, uint128
 from typing_extensions import Unpack, final
@@ -40,12 +40,11 @@ from chia.protocols.pool_protocol import POOL_PROTOCOL_VERSION
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.coin_spend import CoinSpend, compute_additions
+from chia.types.coin_spend import make_spend
 from chia.wallet.conditions import AssertCoinAnnouncement, Condition, ConditionValidTimes
-from chia.wallet.derive_keys import find_owner_sk
 from chia.wallet.puzzles.singleton_top_layer import SINGLETON_LAUNCHER
 from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.util.compute_additions import compute_additions
 from chia.wallet.util.transaction_type import TransactionType
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.util.wallet_types import WalletType
@@ -68,10 +67,10 @@ class PoolWallet:
 
         _protocol_check: ClassVar[WalletProtocol[object]] = cast("PoolWallet", None)
 
-    MINIMUM_INITIAL_BALANCE = 1
-    MINIMUM_RELATIVE_LOCK_HEIGHT = 5
-    MAXIMUM_RELATIVE_LOCK_HEIGHT = 1000
-    DEFAULT_MAX_CLAIM_SPENDS = 100
+    MINIMUM_INITIAL_BALANCE: ClassVar[int] = 1
+    MINIMUM_RELATIVE_LOCK_HEIGHT: ClassVar[int] = 5
+    MAXIMUM_RELATIVE_LOCK_HEIGHT: ClassVar[int] = 1000
+    DEFAULT_MAX_CLAIM_SPENDS: ClassVar[int] = 100
 
     wallet_state_manager: WalletStateManager
     log: logging.Logger
@@ -81,7 +80,6 @@ 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
 
     """
     From the user's perspective, this is not a wallet at all, but a way to control
@@ -232,7 +230,7 @@ class PoolWallet:
     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:
+    async def update_pool_config(self, action_scope: WalletActionScope) -> 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}
@@ -240,15 +238,7 @@ class PoolWallet:
         payout_instructions: str = existing_config.payout_instructions if existing_config is not None else ""
 
         if len(payout_instructions) == 0:
-            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()
+            payout_instructions = (await action_scope.get_puzzle_hash(self.wallet_state_manager)).hex()
             self.log.info(f"New config entry. Generated payout_instructions puzzle hash: {payout_instructions}")
 
         new_config: PoolWalletConfig = PoolWalletConfig(
@@ -262,7 +252,9 @@ class PoolWallet:
         pool_config_dict[new_config.launcher_id] = new_config
         await update_pool_config(self.wallet_state_manager.root_path, list(pool_config_dict.values()))
 
-    async def apply_state_transition(self, new_state: CoinSpend, block_height: uint32) -> bool:
+    async def apply_state_transition(
+        self, new_state: CoinSpend, block_height: uint32, action_scope: WalletActionScope
+    ) -> bool:
         """
         Updates the Pool state (including DB) with new singleton spends.
         The DB must be committed after calling this method. All validation should be done here. Returns True iff
@@ -301,10 +293,10 @@ class PoolWallet:
                     self.next_tx_config = DEFAULT_TX_CONFIG
                 break
 
-        await self.update_pool_config()
+        await self.update_pool_config(action_scope)
         return True
 
-    async def rewind(self, block_height: int) -> bool:
+    async def rewind(self, block_height: int, action_scope: WalletActionScope) -> bool:
         """
         Rolls back all transactions after block_height, and if creation was after block_height, deletes the wallet.
         Returns True if the wallet should be removed.
@@ -320,7 +312,7 @@ class PoolWallet:
                 return True
             else:
                 if await self.get_current_state() != prev_state:
-                    await self.update_pool_config()
+                    await self.update_pool_config(action_scope)
                 return False
         except Exception as e:
             self.log.error(f"Exception rewinding: {e}")
@@ -330,6 +322,7 @@ class PoolWallet:
     async def create(
         cls,
         wallet_state_manager: Any,
+        action_scope: WalletActionScope,
         wallet: Wallet,
         launcher_coin_id: bytes32,
         block_spends: list[CoinSpend],
@@ -359,7 +352,7 @@ class PoolWallet:
                 launcher_spend = spend
         assert launcher_spend is not None
         await wallet_state_manager.pool_store.add_spend(pool_wallet.wallet_id, launcher_spend, block_height)
-        await pool_wallet.update_pool_config()
+        await pool_wallet.update_pool_config(action_scope)
 
         p2_puzzle_hash: bytes32 = (await pool_wallet.get_current_state()).p2_singleton_puzzle_hash
         await wallet_state_manager.add_new_wallet(pool_wallet)
@@ -411,9 +404,7 @@ class PoolWallet:
         standard_wallet = main_wallet
 
         if p2_singleton_delayed_ph is None:
-            p2_singleton_delayed_ph = await main_wallet.get_puzzle_hash(
-                new=not action_scope.config.tx_config.reuse_puzhash
-            )
+            p2_singleton_delayed_ph = await action_scope.get_puzzle_hash(wallet_state_manager)
         if p2_singleton_delay_time is None:
             p2_singleton_delay_time = uint64(604800)
 
@@ -445,18 +436,6 @@ class PoolWallet:
 
         return p2_singleton_puzzle_hash, launcher_coin_id
 
-    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()],
-                (await self.get_current_state()).current.owner_pubkey,
-            )
-        assert self._owner_sk_and_index is not None
-        return self._owner_sk_and_index
-
-    async def get_pool_wallet_index(self) -> uint32:
-        return (await self._get_owner_key_cache())[1]
-
     async def generate_fee_transaction(
         self,
         fee: uint64,
@@ -498,9 +477,7 @@ class PoolWallet:
             delayed_seconds,
             delayed_puzhash,
         )
-        new_full_puzzle: SerializedProgram = SerializedProgram.from_program(
-            create_full_puzzle(new_inner_puzzle, pool_wallet_info.launcher_coin.name())
-        )
+        new_full_puzzle = create_full_puzzle(new_inner_puzzle, pool_wallet_info.launcher_coin.name()).to_serialized()
 
         outgoing_coin_spend, inner_puzzle = create_travel_spend(
             last_coin_spend,
@@ -626,10 +603,10 @@ class PoolWallet:
 
         genesis_launcher_solution: Program = Program.to([puzzle_hash, amount, pool_state_bytes])
 
-        launcher_cs: CoinSpend = CoinSpend(
+        launcher_cs: CoinSpend = make_spend(
             launcher_coin,
-            SerializedProgram.from_program(genesis_launcher_puz),
-            SerializedProgram.from_program(genesis_launcher_solution),
+            genesis_launcher_puz,
+            genesis_launcher_solution,
         )
         launcher_sb = WalletSpendBundle([launcher_cs], G2Element())
 
@@ -711,7 +688,7 @@ class PoolWallet:
 
         # Note the implications of getting owner_puzzlehash from our local wallet right now
         # vs. having pre-arranged the target self-pooling address
-        owner_puzzlehash = await self.standard_wallet.get_new_puzzlehash()
+        owner_puzzlehash = await action_scope.get_puzzle_hash(self.wallet_state_manager)
         owner_pubkey = pool_wallet_info.current.owner_pubkey
         current_state: PoolWalletInfo = await self.get_current_state()
         total_fee = uint64(fee * 2)

chia/protocols/farmer_protocol.py

@@ -3,13 +3,20 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional
 
-from chia_rs import FoliageBlockData, FoliageTransactionBlock, G2Element, PoolTarget, RewardChainBlockUnfinished
+from chia_rs import (
+    ChallengeChainSubSlot,
+    FoliageBlockData,
+    FoliageTransactionBlock,
+    G2Element,
+    PoolTarget,
+    ProofOfSpace,
+    RewardChainBlockUnfinished,
+    RewardChainSubSlot,
+)
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia.types.blockchain_format.classgroup import ClassgroupElement
-from chia.types.blockchain_format.proof_of_space import ProofOfSpace
-from chia.types.blockchain_format.slots import ChallengeChainSubSlot, RewardChainSubSlot
 from chia.util.streamable import Streamable, streamable
 
 """
@@ -49,6 +56,7 @@ class NewSignagePoint(Streamable):
     sub_slot_iters: uint64
     signage_point_index: uint8
     peak_height: uint32
+    last_tx_height: uint32
     sp_source_data: Optional[SignagePointSourceData] = None
 
 

chia/protocols/full_node_protocol.py

@@ -3,15 +3,12 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional
 
+from chia_rs import EndOfSubSlotBundle, FullBlock, SpendBundle, UnfinishedBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
-from chia.types.full_block import FullBlock
 from chia.types.peer_info import TimestampedPeerInfo
-from chia.types.spend_bundle import SpendBundle
-from chia.types.unfinished_block import UnfinishedBlock
 from chia.types.weight_proof import WeightProof
 from chia.util.streamable import Streamable, streamable
 

chia/protocols/harvester_protocol.py

@@ -4,11 +4,10 @@ from dataclasses import dataclass
 from enum import IntEnum
 from typing import Optional
 
-from chia_rs import G1Element, G2Element, RewardChainBlockUnfinished
+from chia_rs import G1Element, G2Element, ProofOfSpace, RewardChainBlockUnfinished
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import int16, uint8, uint32, uint64
 
-from chia.types.blockchain_format.proof_of_space import ProofOfSpace
 from chia.util.streamable import Streamable, streamable
 
 """
@@ -41,7 +40,8 @@ class NewSignagePointHarvester(Streamable):
     signage_point_index: uint8
     sp_hash: bytes32
     pool_difficulties: list[PoolDifficulty]
-    filter_prefix_bits: uint8
+    peak_height: uint32
+    last_tx_height: uint32
 
 
 @streamable

chia/protocols/pool_protocol.py

@@ -5,11 +5,10 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Optional
 
-from chia_rs import G1Element, G2Element
+from chia_rs import G1Element, G2Element, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 
-from chia.types.blockchain_format.proof_of_space import ProofOfSpace
 from chia.util.streamable import Streamable, streamable
 
 POOL_PROTOCOL_VERSION = uint8(1)

chia/protocols/shared_protocol.py

@@ -6,13 +6,13 @@ from typing import Optional
 
 from chia_rs.sized_ints import int16, uint8, uint16
 
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
 from chia.util.streamable import Streamable, streamable
 
 protocol_version = {
     NodeType.FULL_NODE: "0.0.36",
-    NodeType.HARVESTER: "0.0.36",
-    NodeType.FARMER: "0.0.36",
+    NodeType.HARVESTER: "0.0.37",
+    NodeType.FARMER: "0.0.37",
     NodeType.TIMELORD: "0.0.36",
     NodeType.INTRODUCER: "0.0.36",
     NodeType.WALLET: "0.0.38",

chia/protocols/timelord_protocol.py

@@ -3,13 +3,11 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional
 
-from chia_rs import Foliage, RewardChainBlock, RewardChainBlockUnfinished
+from chia_rs import EndOfSubSlotBundle, Foliage, RewardChainBlock, RewardChainBlockUnfinished, SubEpochSummary
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
 from chia.util.streamable import Streamable, streamable
 
 """

chia/protocols/wallet_protocol.py

@@ -5,14 +5,13 @@ from enum import IntEnum
 from typing import Optional
 
 import chia_rs
+from chia_rs import HeaderBlock, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
-from chia.full_node.fee_estimate import FeeEstimateGroup
+from chia.protocols.fee_estimate import FeeEstimateGroup
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.header_block import HeaderBlock
-from chia.types.spend_bundle import SpendBundle
 from chia.util.streamable import Streamable, streamable
 
 """
@@ -21,6 +20,7 @@ Note: When changing this file, also change protocol_message_types.py, and the pr
 """
 
 
+# NOTE: using this assignment to retain automatic testing of these messages
 CoinState = chia_rs.CoinState
 RespondToPhUpdates = chia_rs.RespondToPhUpdates
 

chia/rpc/rpc_client.py

@@ -7,20 +7,19 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from pathlib import Path
 from ssl import SSLContext
-from typing import Any, Optional, TypeVar
+from typing import Any, Optional
 
 import aiohttp
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16
+from typing_extensions import Self
 
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
 from chia.server.server import ssl_context_for_client
 from chia.server.ssl_context import private_ssl_ca_paths
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.task_referencer import create_referenced_task
 
-_T_RpcClient = TypeVar("_T_RpcClient", bound="RpcClient")
-
 
 # It would be better to not inherit from ValueError.  This is being done to separate
 # the possibility to identify these errors in new code from having to review and
@@ -50,12 +49,12 @@ class RpcClient:
 
     @classmethod
     async def create(
-        cls: type[_T_RpcClient],
+        cls,
         self_hostname: str,
         port: uint16,
         root_path: Optional[Path],
         net_config: Optional[dict[str, Any]],
-    ) -> _T_RpcClient:
+    ) -> Self:
         if (root_path is not None) != (net_config is not None):
             raise ValueError("Either both or neither of root_path and net_config must be provided")
 
@@ -89,12 +88,12 @@ class RpcClient:
     @classmethod
     @asynccontextmanager
     async def create_as_context(
-        cls: type[_T_RpcClient],
+        cls,
         self_hostname: str,
         port: uint16,
         root_path: Optional[Path] = None,
         net_config: Optional[dict[str, Any]] = None,
-    ) -> AsyncIterator[_T_RpcClient]:
+    ) -> AsyncIterator[Self]:
         self = await cls.create(
             self_hostname=self_hostname,
             port=port,

chia/rpc/rpc_server.py

@@ -24,8 +24,8 @@ from chia_rs.sized_ints import uint16
 from typing_extensions import Protocol, final
 
 from chia import __version__
+from chia.protocols.outbound_message import NodeType
 from chia.rpc.util import wrap_http_handler
-from chia.server.outbound_message import NodeType
 from chia.server.server import (
     ChiaServer,
     ssl_context_for_client,
@@ -199,7 +199,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
             hostname=self_hostname,
             port=rpc_port,
             max_request_body_size=max_request_body_size,
-            routes=[web.post(route, wrap_http_handler(func)) for (route, func) in self._get_routes().items()],
+            routes=[web.post(route, wrap_http_handler(func, route)) for (route, func) in self._get_routes().items()],
             ssl_context=self.ssl_context,
             prefer_ipv6=self.prefer_ipv6,
         )
@@ -303,7 +303,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
     async def close_connection(self, request: dict[str, Any]) -> EndpointResult:
         node_id = hexstr_to_bytes(request["node_id"])
         if self.rpc_api.service.server is None:
-            raise web.HTTPInternalServerError()
+            raise web.HTTPInternalServerError
         connections_to_close = [c for c in self.rpc_api.service.server.get_connections() if c.peer_node_id == node_id]
         if len(connections_to_close) == 0:
             raise ValueError(f"Connection with node_id {node_id.hex()} does not exist")

chia/rpc/util.py

@@ -66,11 +66,13 @@ def marshal(func: MarshallableRpcEndpoint) -> RpcEndpoint:
                 raise ValueError("Internal Error. Marshalled endpoint was made with clvm_streamable.")
             return response_dict
 
+    rpc_endpoint.__name__ = func.__name__
     return rpc_endpoint
 
 
 def wrap_http_handler(
     f: Callable[[dict[str, Any]], Awaitable[EndpointResult]],
+    route: str,
 ) -> Callable[[aiohttp.web.Request], Awaitable[aiohttp.web.StreamResponse]]:
     async def inner(request: aiohttp.web.Request) -> aiohttp.web.StreamResponse:
         request_data = await request.json()
@@ -82,7 +84,7 @@ def wrap_http_handler(
                 res_object["success"] = True
         except Exception as e:
             tb = traceback.format_exc()
-            log.warning(f"Error while handling message: {tb}")
+            log.warning(f"Error while handling message for {route}: {tb}")
             if len(e.args) > 0:
                 res_object = {"success": False, "error": f"{e.args[0]}", "traceback": f"{tb}"}
             else:

chia/seeder/crawler.py

@@ -19,10 +19,10 @@ from chia_rs.sized_ints import uint32, uint64
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.protocols import full_node_protocol
 from chia.protocols.full_node_protocol import RespondPeers
+from chia.protocols.outbound_message import NodeType
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
 from chia.seeder.crawl_store import CrawlStore
 from chia.seeder.peer_record import PeerRecord, PeerReliability
-from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import PeerInfo

chia/seeder/crawler_api.py

@@ -4,9 +4,9 @@ import logging
 from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
 from chia.protocols import full_node_protocol, wallet_protocol
+from chia.protocols.outbound_message import Message
 from chia.seeder.crawler import Crawler
 from chia.server.api_protocol import ApiMetadata
-from chia.server.outbound_message import Message
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection