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

chia/_tests/wallet/vc_wallet/test_vc_wallet.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Awaitable, Callable, List, Optional
+from collections.abc import Awaitable
+from typing import Any, Callable, Optional
 
 import pytest
 from chia_rs import G2Element
@@ -9,6 +10,7 @@ from typing_extensions import Literal
 
 from chia._tests.environments.wallet import WalletEnvironment, WalletStateTransition, WalletTestFramework
 from chia._tests.util.time_out_assert import time_out_assert_not_none
+from chia.rpc.wallet_request_types import VCAddProofs, VCGet, VCGetList, VCGetProofsForRoot, VCMint, VCRevoke, VCSpend
 from chia.rpc.wallet_rpc_client import WalletRpcClient
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.types.blockchain_format.coin import coin_as_list
@@ -39,7 +41,7 @@ async def mint_cr_cat(
     wallet_node_0: WalletNode,
     client_0: WalletRpcClient,
     full_node_api: FullNodeSimulator,
-    authorized_providers: List[bytes32] = [],
+    authorized_providers: list[bytes32] = [],
     tail: Program = Program.to(None),
     proofs_checker: ProofsChecker = ProofsChecker(["foo", "bar"]),
 ) -> None:
@@ -161,10 +163,13 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
     # Mint a VC
     vc_record = (
         await client_0.vc_mint(
-            did_id,
+            VCMint(
+                did_id=encode_puzzle_hash(did_id, "did"),
+                target_address=encode_puzzle_hash(await wallet_0.get_new_puzzlehash(), "txch"),
+                fee=uint64(1_750_000_000_000),
+                push=True,
+            ),
             wallet_environments.tx_config,
-            target_address=await wallet_0.get_new_puzzlehash(),
-            fee=uint64(1_750_000_000_000),
         )
     ).vc_record
 
@@ -179,7 +184,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
                         # One existing coin has been removed and two ephemeral coins have been removed
                         # Does pending_coin_removal_count attempt to show the number of current pending removals
                         # Or does it intend to just mean all pending removals that we should eventually get states for?
-                        "pending_coin_removal_count": 5,  # 4 for VC mint, 1 for DID mint
+                        "pending_coin_removal_count": 3,
                         "<=#spendable_balance": -1_750_000_000_002,
                         "<=#max_send_amount": -1_750_000_000_002,
                         "set_remainder": True,
@@ -200,7 +205,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
                     "xch": {
                         # 1_750_000_000_000 for VC mint fee, 1 for VC singleton, 1 for DID mint
                         "confirmed_wallet_balance": -1_750_000_000_002,
-                        "pending_coin_removal_count": -5,  # 3 for VC mint, 1 for DID mint
+                        "pending_coin_removal_count": -3,  # 3 for VC mint, 1 for DID mint
                         "set_remainder": True,
                     },
                     "did": {
@@ -214,17 +219,20 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
             WalletStateTransition(),
         ]
     )
-    new_vc_record: Optional[VCRecord] = await client_0.vc_get(vc_record.vc.launcher_id)
+    new_vc_record: Optional[VCRecord] = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
     assert new_vc_record is not None
 
     # Spend VC
     proofs: VCProofs = VCProofs({"foo": "1", "bar": "1", "baz": "1", "qux": "1", "grault": "1"})
     proof_root: bytes32 = proofs.root()
     await client_0.vc_spend(
-        vc_record.vc.launcher_id,
+        VCSpend(
+            vc_id=vc_record.vc.launcher_id,
+            new_proof_hash=proof_root,
+            fee=uint64(100),
+            push=True,
+        ),
         wallet_environments.tx_config,
-        new_proof_hash=proof_root,
-        fee=uint64(100),
     )
     await wallet_environments.process_pending_states(
         [
@@ -241,6 +249,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
                         "spendable_balance": -1,
                         "pending_change": 1,
                         "pending_coin_removal_count": 1,
+                        "max_send_amount": -1,
                     },
                     "vc": {
                         "pending_coin_removal_count": 1,
@@ -256,6 +265,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
                         "spendable_balance": 1,
                         "pending_change": -1,
                         "pending_coin_removal_count": -1,
+                        "max_send_amount": 1,
                     },
                     "vc": {
                         "pending_coin_removal_count": -1,
@@ -265,12 +275,12 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
             WalletStateTransition(),
         ]
     )
-    vc_record_updated: Optional[VCRecord] = await client_0.vc_get(vc_record.vc.launcher_id)
+    vc_record_updated: Optional[VCRecord] = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
     assert vc_record_updated is not None
     assert vc_record_updated.vc.proof_hash == proof_root
 
     # Do a mundane spend
-    await client_0.vc_spend(vc_record.vc.launcher_id, wallet_environments.tx_config)
+    await client_0.vc_spend(VCSpend(vc_id=vc_record.vc.launcher_id, push=True), wallet_environments.tx_config)
     await wallet_environments.process_pending_states(
         [
             WalletStateTransition(
@@ -290,12 +300,15 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
     )
 
     # Add proofs to DB
-    await client_0.vc_add_proofs(proofs.key_value_pairs)
-    await client_0.vc_add_proofs(proofs.key_value_pairs)  # Doing it again just to make sure it doesn't care
-    assert await client_0.vc_get_proofs_for_root(proof_root) == proofs.key_value_pairs
-    vc_records, fetched_proofs = await client_0.vc_get_list()
-    assert len(vc_records) == 1
-    assert fetched_proofs[proof_root.hex()] == proofs.key_value_pairs
+    await client_0.vc_add_proofs(VCAddProofs.from_vc_proofs(proofs))
+    # Doing it again just to make sure it doesn't care
+    await client_0.vc_add_proofs(VCAddProofs.from_vc_proofs(proofs))
+    assert (
+        await client_0.vc_get_proofs_for_root(VCGetProofsForRoot(proof_root))
+    ).to_vc_proofs().key_value_pairs == proofs.key_value_pairs
+    get_list_reponse = await client_0.vc_get_list(VCGetList())
+    assert len(get_list_reponse.vc_records) == 1
+    assert get_list_reponse.proof_dict[proof_root] == proofs.key_value_pairs
 
     # Mint CR-CAT
     await mint_cr_cat(1, wallet_0, wallet_node_0, client_0, full_node_api, [did_id])
@@ -434,7 +447,8 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
 
     # Send the VC to wallet_1 to use for the CR-CATs
     await client_0.vc_spend(
-        vc_record.vc.launcher_id, wallet_environments.tx_config, new_puzhash=await wallet_1.get_new_puzzlehash()
+        VCSpend(vc_id=vc_record.vc.launcher_id, new_puzhash=await wallet_1.get_new_puzzlehash(), push=True),
+        wallet_environments.tx_config,
     )
     await wallet_environments.process_pending_states(
         [
@@ -458,7 +472,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
             ),
         ]
     )
-    await client_1.vc_add_proofs(proofs.key_value_pairs)
+    await client_1.vc_add_proofs(VCAddProofs.from_vc_proofs(proofs))
 
     # Claim the pending approval to our wallet
     await client_1.crcat_approve_pending(
@@ -525,16 +539,18 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
         )
 
     # Test melting a CRCAT
-    tx = (
-        await client_1.cat_spend(
-            env_1.dealias_wallet_id("crcat"),
-            wallet_environments.tx_config,
-            uint64(20),
-            wallet_1_addr,
-            uint64(0),
-            cat_discrepancy=(-50, Program.to(None), Program.to(None)),
-        )
-    ).transaction
+    # This is intended to trigger an edge case where the output and change are the same forcing a new puzhash
+    with wallet_environments.new_puzzle_hashes_allowed():
+        tx = (
+            await client_1.cat_spend(
+                env_1.dealias_wallet_id("crcat"),
+                wallet_environments.tx_config,
+                uint64(20),
+                wallet_1_addr,
+                uint64(0),
+                cat_discrepancy=(-50, Program.to(None), Program.to(None)),
+            )
+        ).transaction
     [tx] = await wallet_node_1.wallet_state_manager.add_pending_transactions([tx])
     await wallet_environments.process_pending_states(
         [
@@ -580,11 +596,14 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
             ),
         ]
     )
-    vc_record_updated = await client_1.vc_get(vc_record_updated.vc.launcher_id)
+    vc_record_updated = (await client_1.vc_get(VCGet(vc_record_updated.vc.launcher_id))).vc_record
     assert vc_record_updated is not None
 
     # Revoke VC
-    await client_0.vc_revoke(vc_record_updated.vc.coin.parent_coin_info, wallet_environments.tx_config, uint64(1))
+    await client_0.vc_revoke(
+        VCRevoke(vc_parent_id=vc_record_updated.vc.coin.parent_coin_info, fee=uint64(1), push=True),
+        wallet_environments.tx_config,
+    )
     await wallet_environments.process_pending_states(
         [
             WalletStateTransition(
@@ -600,6 +619,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
                         "spendable_balance": -1,
                         "pending_change": 1,
                         "pending_coin_removal_count": 1,
+                        "max_send_amount": -1,
                     },
                 },
                 post_block_balance_updates={
@@ -612,6 +632,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
                         "spendable_balance": 1,
                         "pending_change": -1,
                         "pending_coin_removal_count": -1,
+                        "max_send_amount": 1,
                     },
                 },
             ),
@@ -663,7 +684,13 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
 
     vc_record = (
         await client_0.vc_mint(
-            did_id, wallet_environments.tx_config, target_address=await wallet_0.get_new_puzzlehash(), fee=uint64(200)
+            VCMint(
+                did_id=encode_puzzle_hash(did_id, "did"),
+                target_address=encode_puzzle_hash(await wallet_0.get_new_puzzlehash(), "txch"),
+                fee=uint64(200),
+                push=True,
+            ),
+            wallet_environments.tx_config,
         )
     ).vc_record
     await wallet_environments.process_pending_states(
@@ -683,7 +710,7 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
             )
         ]
     )
-    new_vc_record: Optional[VCRecord] = await client_0.vc_get(vc_record.vc.launcher_id)
+    new_vc_record: Optional[VCRecord] = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
     assert new_vc_record is not None
 
     # Test a negative case real quick (mostly unrelated)
@@ -694,7 +721,7 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
             await (await wallet_node_0.wallet_state_manager.get_or_create_vc_wallet()).generate_signed_transaction(
                 new_vc_record.vc.launcher_id,
                 action_scope,
-                new_proof_hash=bytes32([0] * 32),
+                new_proof_hash=bytes32.zeros,
                 self_revoke=True,
             )
 
@@ -702,7 +729,7 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
     async with did_wallet.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=True
     ) as action_scope:
-        await did_wallet.transfer_did(bytes32([0] * 32), uint64(0), False, action_scope)
+        await did_wallet.transfer_did(bytes32.zeros, uint64(0), False, action_scope)
 
     await wallet_environments.process_pending_states(
         [
@@ -716,7 +743,9 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
     )
 
     # Make sure revoking still works
-    await client_0.vc_revoke(new_vc_record.vc.coin.parent_coin_info, wallet_environments.tx_config, uint64(0))
+    await client_0.vc_revoke(
+        VCRevoke(vc_parent_id=new_vc_record.vc.coin.parent_coin_info, push=True), wallet_environments.tx_config
+    )
     await wallet_environments.process_pending_states(
         [
             WalletStateTransition(
@@ -735,7 +764,7 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
             )
         ]
     )
-    vc_record_revoked: Optional[VCRecord] = await client_0.vc_get(vc_record.vc.launcher_id)
+    vc_record_revoked: Optional[VCRecord] = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
     assert vc_record_revoked is None
     assert (
         len(await (await wallet_node_0.wallet_state_manager.get_or_create_vc_wallet()).store.get_unconfirmed_vcs()) == 0
@@ -783,7 +812,7 @@ async def test_cat_wallet_conversion(
         wallet_node_0.wallet_state_manager, wallet_0, Program.to(None).get_tree_hash().hex()
     )
 
-    did_id = bytes32([0] * 32)
+    did_id = bytes32.zeros
     await mint_cr_cat(num_blocks, wallet_0, wallet_node_0, client_0, full_node_api, [did_id])
     await full_node_api.farm_blocks_to_wallet(count=num_blocks, wallet=wallet_0)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_0, timeout=20)

chia/_tests/wallet/wallet_block_tools.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import time
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 from chia_rs import G1Element, G2Element, compute_merkle_set_root
 from chiabip158 import PyBIP158
@@ -30,14 +30,14 @@ from chia.util.hash import std_hash
 from chia.util.ints import uint8, uint32, uint64, uint128
 
 DEFAULT_PROOF_OF_SPACE = ProofOfSpace(
-    bytes32([0] * 32),
+    bytes32.zeros,
     G1Element(),
     None,
     G1Element(),
     uint8(20),
     bytes(32 * 5),
 )
-DEFAULT_VDF_INFO = VDFInfo(bytes32([0] * 32), uint64(1), ClassgroupElement(bytes100([0] * 100)))
+DEFAULT_VDF_INFO = VDFInfo(bytes32.zeros, uint64(1), ClassgroupElement(bytes100.zeros))
 DEFAULT_VDF_PROOF = VDFProof(uint8(0), bytes(100), False)
 
 
@@ -50,14 +50,14 @@ class WalletBlockTools(BlockTools):
     def get_consecutive_blocks(
         self,
         num_blocks: int,
-        block_list_input: Optional[List[FullBlock]] = None,
+        block_list_input: Optional[list[FullBlock]] = None,
         *,
         farmer_reward_puzzle_hash: Optional[bytes32] = None,
         pool_reward_puzzle_hash: Optional[bytes32] = None,
         transaction_data: Optional[SpendBundle] = None,
         genesis_timestamp: Optional[uint64] = None,
         **kwargs: Any,  # We're overriding so there's many arguments no longer used.
-    ) -> List[FullBlock]:
+    ) -> list[FullBlock]:
         assert num_blocks > 0
         constants = self.constants
 
@@ -67,7 +67,7 @@ class WalletBlockTools(BlockTools):
         if block_list_input is None:
             block_list_input = []
 
-        blocks: Dict[bytes32, BlockRecord]
+        blocks: dict[bytes32, BlockRecord]
         if len(block_list_input) == 0:
             height_to_hash = {}
             blocks = {}
@@ -130,10 +130,10 @@ class WalletBlockTools(BlockTools):
 
 
 def load_block_list(
-    block_list: List[FullBlock], constants: ConsensusConstants
-) -> Tuple[Dict[uint32, bytes32], uint64, Dict[bytes32, BlockRecord]]:
-    height_to_hash: Dict[uint32, bytes32] = {}
-    blocks: Dict[bytes32, BlockRecord] = {}
+    block_list: list[FullBlock], constants: ConsensusConstants
+) -> tuple[dict[uint32, bytes32], uint64, dict[bytes32, BlockRecord]]:
+    height_to_hash: dict[uint32, bytes32] = {}
+    blocks: dict[bytes32, BlockRecord] = {}
     sub_slot_iters = constants.SUB_SLOT_ITERS_STARTING
     for full_block in block_list:
         if full_block.height != 0 and len(full_block.finished_sub_slots) > 0:
@@ -154,8 +154,8 @@ def finish_block(
     constants: ConsensusConstants,
     unfinished_block: UnfinishedBlock,
     prev_block: Optional[BlockRecord],
-    blocks: Dict[bytes32, BlockRecord],
-) -> Tuple[FullBlock, BlockRecord]:
+    blocks: dict[bytes32, BlockRecord],
+) -> tuple[FullBlock, BlockRecord]:
     if prev_block is None:
         new_weight = uint128(1)
         new_height = uint32(0)
@@ -170,7 +170,7 @@ def finish_block(
             new_height,
             uint128(1),
             uint8(1),
-            bytes32([0] * 32),
+            bytes32.zeros,
             unfinished_block.reward_chain_block.proof_of_space,
             DEFAULT_VDF_INFO,
             G2Element(),
@@ -199,15 +199,15 @@ def finish_block(
 
 def get_full_block_and_block_record(
     constants: ConsensusConstants,
-    blocks: Dict[bytes32, BlockRecord],
+    blocks: dict[bytes32, BlockRecord],
     last_timestamp: uint64,
     farmer_reward_puzzlehash: bytes32,
     pool_target: PoolTarget,
     prev_block: Optional[BlockRecord],
     block_generator: Optional[BlockGenerator],
-    additions: List[Coin],
-    removals: List[Coin],
-) -> Tuple[FullBlock, BlockRecord, float]:
+    additions: list[Coin],
+    removals: list[Coin],
+) -> tuple[FullBlock, BlockRecord, float]:
     timestamp = last_timestamp + 20
     if prev_block is None:
         height: uint32 = uint32(0)
@@ -241,9 +241,9 @@ def get_full_block_and_block_record(
             )
         )
 
-    byte_array_tx: List[bytearray] = []
-    removal_ids: List[bytes32] = []
-    puzzlehash_coin_map: Dict[bytes32, List[bytes32]] = {}
+    byte_array_tx: list[bytearray] = []
+    removal_ids: list[bytes32] = []
+    puzzlehash_coin_map: dict[bytes32, list[bytes32]] = {}
     for coin in additions:
         puzzlehash_coin_map.setdefault(coin.puzzle_hash, [])
         puzzlehash_coin_map[coin.puzzle_hash].append(coin.name())
@@ -255,7 +255,7 @@ def get_full_block_and_block_record(
     bip158: PyBIP158 = PyBIP158(byte_array_tx)
     filter_hash = std_hash(bytes(bip158.GetEncoded()))
 
-    additions_merkle_items: List[bytes32] = []
+    additions_merkle_items: list[bytes32] = []
     for puzzle, coin_ids in puzzlehash_coin_map.items():
         additions_merkle_items.append(puzzle)
         additions_merkle_items.append(hash_coin_ids(coin_ids))
@@ -263,21 +263,21 @@ def get_full_block_and_block_record(
     additions_root = bytes32(compute_merkle_set_root(additions_merkle_items))
     removals_root = bytes32(compute_merkle_set_root(removal_ids))
 
-    generator_hash = bytes32([0] * 32)
+    generator_hash = bytes32.zeros
     if block_generator is not None:
         generator_hash = std_hash(block_generator.program)
 
     foliage_data = FoliageBlockData(
-        bytes32([0] * 32),
+        bytes32.zeros,
         pool_target,
         G2Element(),
         farmer_reward_puzzlehash,
-        bytes32([0] * 32),
+        bytes32.zeros,
     )
 
     transactions_info = TransactionsInfo(
         generator_hash,
-        bytes32([0] * 32),
+        bytes32.zeros,
         G2Element(),
         fees,
         uint64(constants.MAX_BLOCK_COST_CLVM),
@@ -295,7 +295,7 @@ def get_full_block_and_block_record(
 
     foliage = Foliage(
         prev_block_hash,
-        bytes32([0] * 32),
+        bytes32.zeros,
         foliage_data,
         G2Element(),
         foliage_transaction_block.get_hash(),
@@ -306,7 +306,7 @@ def get_full_block_and_block_record(
         RewardChainBlockUnfinished(
             uint128(1),
             uint8(1),
-            bytes32([0] * 32),
+            bytes32.zeros,
             DEFAULT_PROOF_OF_SPACE,
             None,
             G2Element(),

chia/_tests/weight_proof/test_weight_proof.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Dict, List, Optional, Tuple
+from typing import Optional
 
 import pytest
 
@@ -22,14 +22,14 @@ from chia.util.ints import uint8, uint32, uint64
 
 
 async def load_blocks_dont_validate(
-    blocks: List[FullBlock], constants: ConsensusConstants
-) -> Tuple[
-    Dict[bytes32, HeaderBlock], Dict[uint32, bytes32], Dict[bytes32, BlockRecord], Dict[uint32, SubEpochSummary]
+    blocks: list[FullBlock], constants: ConsensusConstants
+) -> tuple[
+    dict[bytes32, HeaderBlock], dict[uint32, bytes32], dict[bytes32, BlockRecord], dict[uint32, SubEpochSummary]
 ]:
-    header_cache: Dict[bytes32, HeaderBlock] = {}
-    height_to_hash: Dict[uint32, bytes32] = {}
-    sub_blocks: Dict[bytes32, BlockRecord] = {}
-    sub_epoch_summaries: Dict[uint32, SubEpochSummary] = {}
+    header_cache: dict[bytes32, HeaderBlock] = {}
+    height_to_hash: dict[uint32, bytes32] = {}
+    sub_blocks: dict[bytes32, BlockRecord] = {}
+    sub_epoch_summaries: dict[uint32, SubEpochSummary] = {}
     prev_block = None
     difficulty = constants.DIFFICULTY_STARTING
     sub_slot_iters = constants.SUB_SLOT_ITERS_STARTING
@@ -74,7 +74,7 @@ async def load_blocks_dont_validate(
         )
         sub_blocks[block.header_hash] = sub_block
         height_to_hash[block.height] = block.header_hash
-        header_cache[block.header_hash] = get_block_header(block, [], [])
+        header_cache[block.header_hash] = get_block_header(block)
         if sub_block.sub_epoch_summary_included is not None:
             sub_epoch_summaries[block.height] = sub_block.sub_epoch_summary_included
         prev_block = block
@@ -82,15 +82,15 @@ async def load_blocks_dont_validate(
 
 
 async def _test_map_summaries(
-    blocks: List[FullBlock],
-    header_cache: Dict[bytes32, HeaderBlock],
-    height_to_hash: Dict[uint32, bytes32],
-    sub_blocks: Dict[bytes32, BlockRecord],
-    summaries: Dict[uint32, SubEpochSummary],
+    blocks: list[FullBlock],
+    header_cache: dict[bytes32, HeaderBlock],
+    height_to_hash: dict[uint32, bytes32],
+    sub_blocks: dict[bytes32, BlockRecord],
+    summaries: dict[uint32, SubEpochSummary],
     constants: ConsensusConstants,
 ) -> None:
     curr = sub_blocks[blocks[-1].header_hash]
-    orig_summaries: Dict[int, SubEpochSummary] = {}
+    orig_summaries: dict[int, SubEpochSummary] = {}
     while curr.height > 0:
         if curr.sub_epoch_summary_included is not None:
             orig_summaries[curr.height] = curr.sub_epoch_summary_included
@@ -114,7 +114,7 @@ async def _test_map_summaries(
 class TestWeightProof:
     @pytest.mark.anyio
     async def test_weight_proof_map_summaries_1(
-        self, default_400_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_400_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
             default_400_blocks, blockchain_constants
@@ -125,7 +125,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof_map_summaries_2(
-        self, default_1000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_1000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
             default_1000_blocks, blockchain_constants
@@ -136,7 +136,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof_summaries_1000_blocks(
-        self, default_1000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_1000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = default_1000_blocks
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
@@ -158,7 +158,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof_bad_peak_hash(
-        self, default_1000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_1000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = default_1000_blocks
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
@@ -173,7 +173,7 @@ class TestWeightProof:
     @pytest.mark.anyio
     @pytest.mark.skip(reason="broken")
     async def test_weight_proof_from_genesis(
-        self, default_400_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_400_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = default_400_blocks
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
@@ -188,7 +188,7 @@ class TestWeightProof:
         assert wp is not None
 
     @pytest.mark.anyio
-    async def test_weight_proof_edge_cases(self, bt: BlockTools, default_400_blocks: List[FullBlock]) -> None:
+    async def test_weight_proof_edge_cases(self, bt: BlockTools, default_400_blocks: list[FullBlock]) -> None:
         blocks = default_400_blocks
 
         blocks = bt.get_consecutive_blocks(
@@ -275,7 +275,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof1000(
-        self, default_1000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_1000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = default_1000_blocks
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
@@ -294,7 +294,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof1000_pre_genesis_empty_slots(
-        self, pre_genesis_empty_slots_1000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, pre_genesis_empty_slots_1000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = pre_genesis_empty_slots_1000_blocks
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
@@ -314,7 +314,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof10000__blocks_compact(
-        self, default_10000_blocks_compact: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_10000_blocks_compact: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = default_10000_blocks_compact
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
@@ -333,7 +333,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof1000_partial_blocks_compact(
-        self, bt: BlockTools, default_10000_blocks_compact: List[FullBlock]
+        self, bt: BlockTools, default_10000_blocks_compact: list[FullBlock]
     ) -> None:
         blocks = bt.get_consecutive_blocks(
             100,
@@ -355,7 +355,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof10000(
-        self, default_10000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_10000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = default_10000_blocks
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
@@ -375,7 +375,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_check_num_of_samples(
-        self, default_10000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_10000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = default_10000_blocks
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
@@ -396,7 +396,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof_extend_no_ses(
-        self, default_1000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_1000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = default_1000_blocks
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
@@ -424,7 +424,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof_extend_new_ses(
-        self, default_1000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_1000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = default_1000_blocks
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
@@ -468,7 +468,7 @@ class TestWeightProof:
 
     @pytest.mark.anyio
     async def test_weight_proof_extend_multiple_ses(
-        self, default_1000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_1000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         blocks = default_1000_blocks
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(

chia/apis.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from chia.farmer.farmer_api import FarmerAPI
+from chia.full_node.full_node_api import FullNodeAPI
+from chia.harvester.harvester_api import HarvesterAPI
+from chia.introducer.introducer_api import IntroducerAPI
+from chia.server.api_protocol import ApiProtocol
+from chia.server.outbound_message import NodeType
+from chia.timelord.timelord_api import TimelordAPI
+from chia.wallet.wallet_node_api import WalletNodeAPI
+
+ApiProtocolRegistry: dict[NodeType, type[ApiProtocol]] = {
+    NodeType.FULL_NODE: FullNodeAPI,
+    NodeType.WALLET: WalletNodeAPI,
+    NodeType.INTRODUCER: IntroducerAPI,
+    NodeType.TIMELORD: TimelordAPI,
+    NodeType.FARMER: FarmerAPI,
+    NodeType.HARVESTER: HarvesterAPI,
+}