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

chia/_tests/core/mempool/test_mempool_performance.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import pytest
+from chia_rs import FullBlock
 from chia_rs.sized_ints import uint64, uint128
 
 from chia._tests.util.misc import BenchmarkRunner, wallet_height_at_least
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
-from chia.types.full_block import FullBlock
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.peer_info import PeerInfo
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
@@ -43,7 +43,8 @@ async def test_mempool_update_performance(
     fee_amount = uint64(2213)
     await time_out_assert(30, wallet_balance_at_least, True, wallet_node, send_amount + fee_amount)
 
-    ph = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False, sign=True) as action_scope:
         await wallet.generate_signed_transaction([send_amount], [ph], action_scope, fee_amount)
     [big_transaction] = action_scope.side_effects.transactions

chia/_tests/core/mempool/test_singleton_fast_forward.py

@@ -5,7 +5,7 @@ import dataclasses
 from typing import Any, Optional
 
 import pytest
-from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, CoinSpend, G1Element, G2Element, PrivateKey, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 from chiabip158 import PyBIP158
@@ -23,31 +23,28 @@ from chia._tests.core.mempool.test_mempool_manager import (
 from chia._tests.util.key_tool import KeyTool
 from chia._tests.util.spend_sim import SimClient, SpendSim, sim_and_client
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.full_node.eligible_coin_spends import (
+    SingletonFastForward,
+    perform_the_fast_forward,
+)
 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, make_spend
+from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
-from chia.types.eligible_coin_spends import EligibleCoinSpends, UnspentLineageInfo, perform_the_fast_forward
 from chia.types.internal_mempool_item import InternalMempoolItem
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
-from chia.types.mempool_item import BundleCoinSpend
-from chia.types.spend_bundle import SpendBundle
+from chia.types.mempool_item import BundleCoinSpend, UnspentLineageInfo
 from chia.util.errors import Err
 from chia.wallet.puzzles import p2_conditions, p2_delegated_puzzle_or_hidden_puzzle
 from chia.wallet.puzzles import singleton_top_layer_v1_1 as singleton_top_layer
 
 
-@pytest.mark.anyio
-async def test_process_fast_forward_spends_nothing_to_do() -> None:
+def test_process_fast_forward_spends_nothing_to_do() -> None:
     """
     This tests the case when we don't have an eligible coin, so there is
     nothing to fast forward and the item remains unchanged
     """
-
-    async def get_unspent_lineage_info_for_puzzle_hash(_: bytes32) -> Optional[UnspentLineageInfo]:
-        assert False  # pragma: no cover
-
     sk = AugSchemeMPL.key_gen(b"b" * 32)
     g1 = sk.get_g1()
     sig = AugSchemeMPL.sign(sk, b"foobar", g1)
@@ -58,50 +55,37 @@ async def test_process_fast_forward_spends_nothing_to_do() -> None:
     assert item.bundle_coin_spends[TEST_COIN_ID].eligible_for_fast_forward is False
     internal_mempool_item = InternalMempoolItem(sb, item.conds, item.height_added_to_mempool, item.bundle_coin_spends)
     original_version = dataclasses.replace(internal_mempool_item)
-    eligible_coin_spends = EligibleCoinSpends()
-    bundle_coin_spends = await eligible_coin_spends.process_fast_forward_spends(
-        mempool_item=internal_mempool_item,
-        get_unspent_lineage_info_for_puzzle_hash=get_unspent_lineage_info_for_puzzle_hash,
-        height=TEST_HEIGHT,
-        constants=DEFAULT_CONSTANTS,
+    singleton_ff = SingletonFastForward()
+    bundle_coin_spends = singleton_ff.process_fast_forward_spends(
+        mempool_item=internal_mempool_item, height=TEST_HEIGHT, constants=DEFAULT_CONSTANTS
     )
-    assert eligible_coin_spends == EligibleCoinSpends()
+    assert singleton_ff == SingletonFastForward()
     assert bundle_coin_spends == original_version.bundle_coin_spends
 
 
-@pytest.mark.anyio
-async def test_process_fast_forward_spends_unknown_ff() -> None:
+def test_process_fast_forward_spends_unknown_ff() -> None:
     """
     This tests the case when we process for the first time but we are unable
-    to lookup the latest version from the DB
+    to lookup the latest version from the item's latest singleton lineage
     """
-
-    async def get_unspent_lineage_info_for_puzzle_hash(puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
-        if puzzle_hash == IDENTITY_PUZZLE_HASH:
-            return None
-        assert False  # pragma: no cover
-
     test_coin = Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(1))
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
     sb = spend_bundle_from_conditions(conditions, test_coin)
     item = mempool_item_from_spendbundle(sb)
     # The coin is eligible for fast forward
     assert item.bundle_coin_spends[test_coin.name()].eligible_for_fast_forward is True
+    item.bundle_coin_spends[test_coin.name()].latest_singleton_lineage = None
     internal_mempool_item = InternalMempoolItem(sb, item.conds, item.height_added_to_mempool, item.bundle_coin_spends)
-    eligible_coin_spends = EligibleCoinSpends()
+    singleton_ff = SingletonFastForward()
     # We have no fast forward records yet, so we'll process this coin for the
-    # first time here, but the DB lookup will return None
+    # first time here, but the item's latest singleton lineage returns None
     with pytest.raises(ValueError, match="Cannot proceed with singleton spend fast forward."):
-        await eligible_coin_spends.process_fast_forward_spends(
-            mempool_item=internal_mempool_item,
-            get_unspent_lineage_info_for_puzzle_hash=get_unspent_lineage_info_for_puzzle_hash,
-            height=TEST_HEIGHT,
-            constants=DEFAULT_CONSTANTS,
+        singleton_ff.process_fast_forward_spends(
+            mempool_item=internal_mempool_item, height=TEST_HEIGHT, constants=DEFAULT_CONSTANTS
         )
 
 
-@pytest.mark.anyio
-async def test_process_fast_forward_spends_latest_unspent() -> None:
+def test_process_fast_forward_spends_latest_unspent() -> None:
     """
     This tests the case when we are the latest singleton version already, so
     we don't need to fast forward, we just need to set the next version from
@@ -110,18 +94,9 @@ async def test_process_fast_forward_spends_latest_unspent() -> None:
     test_amount = uint64(3)
     test_coin = Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, test_amount)
     test_unspent_lineage_info = UnspentLineageInfo(
-        coin_id=test_coin.name(),
-        coin_amount=test_coin.amount,
-        parent_id=test_coin.parent_coin_info,
-        parent_amount=test_coin.amount,
-        parent_parent_id=TEST_COIN_ID,
+        coin_id=test_coin.name(), parent_id=test_coin.parent_coin_info, parent_parent_id=TEST_COIN_ID
     )
 
-    async def get_unspent_lineage_info_for_puzzle_hash(puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
-        if puzzle_hash == IDENTITY_PUZZLE_HASH:
-            return test_unspent_lineage_info
-        assert False  # pragma: no cover
-
     # At this point, spends are considered *potentially* eligible for singleton
     # fast forward mainly when their amount is odd and they don't have conditions
     # that disqualify them
@@ -129,27 +104,21 @@ async def test_process_fast_forward_spends_latest_unspent() -> None:
     sb = spend_bundle_from_conditions(conditions, test_coin)
     item = mempool_item_from_spendbundle(sb)
     assert item.bundle_coin_spends[test_coin.name()].eligible_for_fast_forward is True
+    item.bundle_coin_spends[test_coin.name()].latest_singleton_lineage = test_unspent_lineage_info
     internal_mempool_item = InternalMempoolItem(sb, item.conds, item.height_added_to_mempool, item.bundle_coin_spends)
     original_version = dataclasses.replace(internal_mempool_item)
-    eligible_coin_spends = EligibleCoinSpends()
-    bundle_coin_spends = await eligible_coin_spends.process_fast_forward_spends(
-        mempool_item=internal_mempool_item,
-        get_unspent_lineage_info_for_puzzle_hash=get_unspent_lineage_info_for_puzzle_hash,
-        height=TEST_HEIGHT,
-        constants=DEFAULT_CONSTANTS,
+    singleton_ff = SingletonFastForward()
+    bundle_coin_spends = singleton_ff.process_fast_forward_spends(
+        mempool_item=internal_mempool_item, height=TEST_HEIGHT, constants=DEFAULT_CONSTANTS
     )
     child_coin = item.bundle_coin_spends[test_coin.name()].additions[0]
     expected_fast_forward_spends = {
         IDENTITY_PUZZLE_HASH: UnspentLineageInfo(
-            coin_id=child_coin.name(),
-            coin_amount=child_coin.amount,
-            parent_id=test_coin.name(),
-            parent_amount=test_coin.amount,
-            parent_parent_id=test_coin.parent_coin_info,
+            coin_id=child_coin.name(), parent_id=test_coin.name(), parent_parent_id=test_coin.parent_coin_info
         )
     }
     # We have set the next version from our additions to chain ff spends
-    assert eligible_coin_spends.fast_forward_spends == expected_fast_forward_spends
+    assert singleton_ff.fast_forward_spends == expected_fast_forward_spends
     # We didn't need to fast forward the item so it stays as is
     assert bundle_coin_spends == original_version.bundle_coin_spends
 
@@ -202,9 +171,7 @@ def test_perform_the_fast_forward() -> None:
     test_spend_data = BundleCoinSpend(test_coin_spend, False, True, [test_child_coin])
     test_unspent_lineage_info = UnspentLineageInfo(
         coin_id=latest_unspent_coin.name(),
-        coin_amount=latest_unspent_coin.amount,
         parent_id=latest_unspent_coin.parent_coin_info,
-        parent_amount=test_child_coin.amount,
         parent_parent_id=test_child_coin.parent_coin_info,
     )
     # Start from a fresh state of fast forward spends
@@ -227,9 +194,7 @@ def test_perform_the_fast_forward() -> None:
     # (previously latest unspent)
     expected_unspent_lineage_info = UnspentLineageInfo(
         coin_id=expected_child_coin.name(),
-        coin_amount=expected_child_coin.amount,
         parent_id=latest_unspent_coin.name(),
-        parent_amount=latest_unspent_coin.amount,
         parent_parent_id=latest_unspent_coin.parent_coin_info,
     )
     assert fast_forward_spends == {test_ph: expected_unspent_lineage_info}
@@ -292,16 +257,16 @@ def make_singleton_coin_spend(
     solution = singleton_top_layer.solution_for_singleton(lineage_proof, uint64(coin_to_spend.amount), inner_solution)
     if is_eve_spend:
         # Parent here is the launcher coin
-        puzzle_reveal = SerializedProgram.from_program(
-            singleton_top_layer.puzzle_for_singleton(parent_coin_spend.coin.name(), inner_puzzle)
-        )
+        puzzle_reveal = singleton_top_layer.puzzle_for_singleton(
+            parent_coin_spend.coin.name(), inner_puzzle
+        ).to_serialized()
     else:
         puzzle_reveal = parent_coin_spend.puzzle_reveal
     return make_spend(coin_to_spend, puzzle_reveal, solution), delegated_puzzle
 
 
 async def prepare_singleton_eve(
-    sim: SpendSim, sim_client: SimClient, is_eligible_for_ff: bool, start_amount: uint64, singleton_amount: uint64
+    sim: SpendSim, sim_client: SimClient, is_eligible_for_ff: bool, singleton_amount: uint64
 ) -> tuple[Program, CoinSpend, Program]:
     # Generate starting info
     key_lookup = KeyTool()
@@ -319,11 +284,11 @@ async def prepare_singleton_eve(
     starting_coin = records[0].coin
     # Launching
     conditions, launcher_coin_spend = singleton_top_layer.launch_conditions_and_coinsol(
-        coin=starting_coin, inner_puzzle=inner_puzzle, comment=[], amount=start_amount
+        coin=starting_coin, inner_puzzle=inner_puzzle, comment=[], amount=singleton_amount
     )
     # Keep a remaining coin with an even amount
     conditions.append(
-        Program.to([ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, starting_coin.amount - start_amount - 1])
+        Program.to([ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, starting_coin.amount - singleton_amount - 1])
     )
     # Create a solution for standard transaction
     delegated_puzzle = p2_conditions.puzzle_for_conditions(conditions)
@@ -351,10 +316,10 @@ async def prepare_singleton_eve(
 
 
 async def prepare_and_test_singleton(
-    sim: SpendSim, sim_client: SimClient, is_eligible_for_ff: bool, start_amount: uint64, singleton_amount: uint64
+    sim: SpendSim, sim_client: SimClient, is_eligible_for_ff: bool, singleton_amount: uint64
 ) -> tuple[Coin, CoinSpend, Program, Coin]:
     inner_puzzle, eve_coin_spend, eve_signing_puzzle = await prepare_singleton_eve(
-        sim, sim_client, is_eligible_for_ff, start_amount, singleton_amount
+        sim, sim_client, is_eligible_for_ff, singleton_amount
     )
     # At this point we don't have any unspent singleton
     singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
@@ -374,11 +339,7 @@ async def prepare_and_test_singleton(
         singleton_puzzle_hash
     )
     assert unspent_lineage_info == UnspentLineageInfo(
-        coin_id=singleton.name(),
-        coin_amount=singleton.amount,
-        parent_id=eve_coin.name(),
-        parent_amount=eve_coin.amount,
-        parent_parent_id=eve_coin.parent_coin_info,
+        coin_id=singleton.name(), parent_id=eve_coin.name(), parent_parent_id=eve_coin.parent_coin_info
     )
     return singleton, eve_coin_spend, inner_puzzle, remaining_coin
 
@@ -393,7 +354,7 @@ async def test_singleton_fast_forward_solo() -> None:
     SINGLETON_AMOUNT = uint64(1337)
     async with sim_and_client() as (sim, sim_client):
         singleton, eve_coin_spend, inner_puzzle, _ = await prepare_and_test_singleton(
-            sim, sim_client, True, SINGLETON_AMOUNT, SINGLETON_AMOUNT
+            sim, sim_client, True, SINGLETON_AMOUNT
         )
         singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
         inner_puzzle_hash = inner_puzzle.get_tree_hash()
@@ -410,9 +371,7 @@ async def test_singleton_fast_forward_solo() -> None:
         assert singleton_child.amount == SINGLETON_AMOUNT
         assert unspent_lineage_info == UnspentLineageInfo(
             coin_id=singleton_child.name(),
-            coin_amount=singleton_child.amount,
             parent_id=eve_coin_spend.coin.name(),
-            parent_amount=singleton.amount,
             parent_parent_id=eve_coin_spend.coin.parent_coin_info,
         )
 
@@ -434,12 +393,10 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
     get properly fast forwarded to the latest unspent (when it's eligible) or
     get correctly rejected as a double spend (when it's not eligible)
     """
-    START_AMOUNT = uint64(1337)
-    # We're decrementing the next iteration's amount for testing purposes
-    SINGLETON_AMOUNT = uint64(1335)
+    SINGLETON_AMOUNT = uint64(1337)
     async with sim_and_client() as (sim, sim_client):
         singleton, eve_coin_spend, inner_puzzle, remaining_coin = await prepare_and_test_singleton(
-            sim, sim_client, is_eligible_for_ff, START_AMOUNT, SINGLETON_AMOUNT
+            sim, sim_client, is_eligible_for_ff, SINGLETON_AMOUNT
         )
         # Let's spend this first version, to create a bigger singleton child
         singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
@@ -456,8 +413,8 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
             eve_coin_spend, singleton, inner_puzzle, inner_conditions
         )
         # Spend also a remaining coin
-        remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]])
+        remaining_spend_solution = SerializedProgram.to(
+            [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]]
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         await make_and_send_spend_bundle(
@@ -475,15 +432,11 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
         singleton_child, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
         assert singleton_child.amount == SINGLETON_AMOUNT
         assert unspent_lineage_info == UnspentLineageInfo(
-            coin_id=singleton_child.name(),
-            coin_amount=singleton_child.amount,
-            parent_id=singleton.name(),
-            parent_amount=singleton.amount,
-            parent_parent_id=eve_coin_spend.coin.name(),
+            coin_id=singleton_child.name(), parent_id=singleton.name(), parent_parent_id=eve_coin_spend.coin.name()
         )
         # Now let's spend the first version again (despite being already spent by now)
-        remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]])
+        remaining_spend_solution = SerializedProgram.to(
+            [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]]
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         status, error = await make_and_send_spend_bundle(
@@ -506,11 +459,7 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
             )
             singleton_grandchild, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
             assert unspent_lineage_info == UnspentLineageInfo(
-                coin_id=singleton_grandchild.name(),
-                coin_amount=singleton_grandchild.amount,
-                parent_id=singleton_child.name(),
-                parent_amount=singleton_child.amount,
-                parent_parent_id=singleton.name(),
+                coin_id=singleton_grandchild.name(), parent_id=singleton_child.name(), parent_parent_id=singleton.name()
             )
         else:
             # As this singleton is not eligible for fast forward, attempting to
@@ -526,12 +475,10 @@ async def test_singleton_fast_forward_same_block() -> None:
     singleton version, all in the same block, to make sure they get properly
     fast forwarded and chained down to a latest unspent version
     """
-    START_AMOUNT = uint64(1337)
-    # We're decrementing the next iteration's amount for testing purposes
-    SINGLETON_AMOUNT = uint64(1335)
+    SINGLETON_AMOUNT = uint64(1337)
     async with sim_and_client() as (sim, sim_client):
         singleton, eve_coin_spend, inner_puzzle, remaining_coin = await prepare_and_test_singleton(
-            sim, sim_client, True, START_AMOUNT, SINGLETON_AMOUNT
+            sim, sim_client, True, SINGLETON_AMOUNT
         )
         # Let's spend this first version, to create a bigger singleton child
         singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
@@ -547,8 +494,8 @@ async def test_singleton_fast_forward_same_block() -> None:
         # Spend also a remaining coin. Change amount to create a new coin ID.
         # The test assumes any odd amount is a singleton, so we must keep it
         # even
-        remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - 2]])
+        remaining_spend_solution = SerializedProgram.to(
+            [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - 2]]
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         await make_and_send_spend_bundle(sim, sim_client, [remaining_coin_spend, singleton_coin_spend], aggsig=sig)
@@ -558,11 +505,7 @@ async def test_singleton_fast_forward_same_block() -> None:
         singleton_child, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
         assert singleton_child.amount == SINGLETON_AMOUNT
         assert unspent_lineage_info == UnspentLineageInfo(
-            coin_id=singleton_child.name(),
-            coin_amount=singleton_child.amount,
-            parent_id=singleton.name(),
-            parent_amount=singleton.amount,
-            parent_parent_id=eve_coin_spend.coin.name(),
+            coin_id=singleton_child.name(), parent_id=singleton.name(), parent_parent_id=eve_coin_spend.coin.name()
         )
         # Now let's send 3 arbitrary spends of the already spent singleton in
         # one block. They should all properly fast forward
@@ -596,14 +539,8 @@ async def test_singleton_fast_forward_same_block() -> None:
         assert unspent_lineage_info is not None
         # The unspent coin ID should reflect the latest version
         assert unspent_lineage_info.coin_id == latest_singleton.name()
-        # The latest version should have the last random amount
-        assert latest_singleton.amount == SINGLETON_AMOUNT
-        # The unspent coin amount should reflect the latest version
-        assert unspent_lineage_info.coin_amount == latest_singleton.amount
         # The unspent parent ID should reflect the latest version's parent
         assert unspent_lineage_info.parent_id == latest_singleton.parent_coin_info
-        # The one before it should have the second last random amount
-        assert unspent_lineage_info.parent_amount == SINGLETON_AMOUNT
 
 
 @pytest.mark.anyio
@@ -615,7 +552,7 @@ async def test_mempool_items_immutability_on_ff() -> None:
     SINGLETON_AMOUNT = uint64(1337)
     async with sim_and_client() as (sim, sim_client):
         singleton, eve_coin_spend, inner_puzzle, remaining_coin = await prepare_and_test_singleton(
-            sim, sim_client, True, SINGLETON_AMOUNT, SINGLETON_AMOUNT
+            sim, sim_client, True, SINGLETON_AMOUNT
         )
         singleton_name = singleton.name()
         singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
@@ -630,8 +567,8 @@ async def test_mempool_items_immutability_on_ff() -> None:
         singleton_coin_spend, singleton_signing_puzzle = make_singleton_coin_spend(
             eve_coin_spend, singleton, inner_puzzle, inner_conditions
         )
-        remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]])
+        remaining_spend_solution = SerializedProgram.to(
+            [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]]
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         await make_and_send_spend_bundle(
@@ -649,16 +586,12 @@ async def test_mempool_items_immutability_on_ff() -> None:
         singleton_child_name = singleton_child.name()
         assert singleton_child.amount == SINGLETON_AMOUNT
         assert unspent_lineage_info == UnspentLineageInfo(
-            coin_id=singleton_child_name,
-            coin_amount=singleton_child.amount,
-            parent_id=singleton_name,
-            parent_amount=singleton.amount,
-            parent_parent_id=eve_coin_spend.coin.name(),
+            coin_id=singleton_child_name, parent_id=singleton_name, parent_parent_id=eve_coin_spend.coin.name()
         )
         # Now let's spend the first version again (despite being already spent
         # by now) to exercise its fast forward.
-        remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]])
+        remaining_spend_solution = SerializedProgram.to(
+            [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]]
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         sb = SpendBundle([remaining_coin_spend, singleton_coin_spend], sig)
@@ -669,9 +602,7 @@ async def test_mempool_items_immutability_on_ff() -> None:
         original_item = copy.copy(sim_client.service.mempool_manager.get_mempool_item(sb_name))
         original_filter = sim_client.service.mempool_manager.get_filter()
         # Let's trigger the fast forward by creating a mempool bundle
-        result = await sim.mempool_manager.create_bundle_from_mempool(
-            sim_client.service.block_records[-1].header_hash,
-        )
+        result = sim.mempool_manager.create_bundle_from_mempool(sim_client.service.block_records[-1].header_hash)
         assert result is not None
         bundle, _ = result
         # Make sure the mempool bundle we created contains the result of our
@@ -694,11 +625,11 @@ async def test_double_spend_ff_spend_no_latest_unspent() -> None:
     This test covers the scenario where we receive a spend bundle with a
     singleton fast forward spend that has currently no unspent coin.
     """
-    test_amount = uint64(1337)
+    singleton_amount = uint64(1337)
     async with sim_and_client() as (sim, sim_client):
         # Prepare a singleton spend
         singleton, eve_coin_spend, inner_puzzle, _ = await prepare_and_test_singleton(
-            sim, sim_client, True, start_amount=test_amount, singleton_amount=test_amount
+            sim, sim_client, True, singleton_amount=singleton_amount
         )
         singleton_name = singleton.name()
         singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
@@ -708,7 +639,7 @@ async def test_double_spend_ff_spend_no_latest_unspent() -> None:
         sig = AugSchemeMPL.sign(sk, b"foobar", g1)
         inner_conditions: list[list[Any]] = [
             [ConditionOpcode.AGG_SIG_UNSAFE, bytes(g1), b"foobar"],
-            [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, test_amount],
+            [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, singleton_amount],
         ]
         singleton_coin_spend, _ = make_singleton_coin_spend(eve_coin_spend, singleton, inner_puzzle, inner_conditions)
         # Get its current latest unspent info
@@ -717,9 +648,7 @@ async def test_double_spend_ff_spend_no_latest_unspent() -> None:
         )
         assert unspent_lineage_info == UnspentLineageInfo(
             coin_id=singleton_name,
-            coin_amount=test_amount,
             parent_id=eve_coin_spend.coin.name(),
-            parent_amount=eve_coin_spend.coin.amount,
             parent_parent_id=eve_coin_spend.coin.parent_coin_info,
         )
         # Let's remove this latest unspent coin from the coin store

chia/_tests/core/server/flood.py

@@ -69,7 +69,7 @@ async def main() -> None:
         logger = create_logger(file=file)
 
         async def f() -> None:
-            await asyncio.gather(*[tcp_echo_client(task_counter=f"{i}", logger=logger) for i in range(0, NUM_CLIENTS)])
+            await asyncio.gather(*[tcp_echo_client(task_counter=f"{i}", logger=logger) for i in range(NUM_CLIENTS)])
 
         task = create_referenced_task(f())
         try:

chia/_tests/core/server/test_dos.py

@@ -13,9 +13,9 @@ from chia_rs.sized_ints import uint8, uint16, uint64
 import chia.server.server
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.protocols import full_node_protocol
+from chia.protocols.outbound_message import Message, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Capability, Handshake
-from chia.server.outbound_message import Message, make_msg
 from chia.server.rate_limits import RateLimiter
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection

chia/_tests/core/server/test_node_discovery.py

@@ -20,15 +20,15 @@ async def test_enable_private_networks(
 
     # Missing `enable_private_networks` config entry in introducer_peer should default to False for back compat
     discovery0 = FullNodeDiscovery(
-        chia_server,
-        0,
-        SIMULATOR_ROOT_PATH / Path(chia_server.config["peers_file_path"]),
-        {"host": "introducer.chia.net", "port": 8444},
-        [],
-        0,
-        chia_server.config["selected_network"],
-        None,
-        Logger("node_discovery_tests"),
+        server=chia_server,
+        target_outbound_count=0,
+        peers_file_path=SIMULATOR_ROOT_PATH / Path(chia_server.config["peers_file_path"]),
+        introducer_info={"host": "introducer.chia.net", "port": 8444},
+        dns_servers=[],
+        peer_connect_interval=0,
+        selected_network=chia_server.config["selected_network"],
+        default_port=None,
+        log=Logger("node_discovery_tests"),
     )
     assert discovery0 is not None
     assert discovery0.enable_private_networks is False
@@ -36,17 +36,31 @@ async def test_enable_private_networks(
     assert discovery0.address_manager is not None
     assert discovery0.address_manager.allow_private_subnets is False
 
+    # Missing `default_port` but known selected_network should automatically pick a port
+    discovery0 = FullNodeDiscovery(
+        server=chia_server,
+        target_outbound_count=0,
+        peers_file_path=SIMULATOR_ROOT_PATH / Path(chia_server.config["peers_file_path"]),
+        introducer_info={"host": "introducer.chia.net", "port": 8444},
+        dns_servers=[],
+        peer_connect_interval=0,
+        selected_network="testnet7",
+        default_port=None,
+        log=Logger("node_discovery_tests"),
+    )
+    assert discovery0.default_port == 58444
+
     # Test with enable_private_networks set to False in Config
     discovery1 = FullNodeDiscovery(
-        chia_server,
-        0,
-        SIMULATOR_ROOT_PATH / Path(chia_server.config["peers_file_path"]),
-        {"host": "introducer.chia.net", "port": 8444, "enable_private_networks": False},
-        [],
-        0,
-        chia_server.config["selected_network"],
-        None,
-        Logger("node_discovery_tests"),
+        server=chia_server,
+        target_outbound_count=0,
+        peers_file_path=SIMULATOR_ROOT_PATH / Path(chia_server.config["peers_file_path"]),
+        introducer_info={"host": "introducer.chia.net", "port": 8444, "enable_private_networks": False},
+        dns_servers=[],
+        peer_connect_interval=0,
+        selected_network=chia_server.config["selected_network"],
+        default_port=None,
+        log=Logger("node_discovery_tests"),
     )
     assert discovery1 is not None
     assert discovery1.enable_private_networks is False
@@ -56,15 +70,15 @@ async def test_enable_private_networks(
 
     # Test with enable_private_networks set to True in Config
     discovery2 = FullNodeDiscovery(
-        chia_server,
-        0,
-        SIMULATOR_ROOT_PATH / Path(chia_server.config["peers_file_path"]),
-        {"host": "introducer.chia.net", "port": 8444, "enable_private_networks": True},
-        [],
-        0,
-        chia_server.config["selected_network"],
-        None,
-        Logger("node_discovery_tests"),
+        server=chia_server,
+        target_outbound_count=0,
+        peers_file_path=SIMULATOR_ROOT_PATH / Path(chia_server.config["peers_file_path"]),
+        introducer_info={"host": "introducer.chia.net", "port": 8444, "enable_private_networks": True},
+        dns_servers=[],
+        peer_connect_interval=0,
+        selected_network=chia_server.config["selected_network"],
+        default_port=None,
+        log=Logger("node_discovery_tests"),
     )
     assert discovery2 is not None
     assert discovery2.enable_private_networks is True

chia/_tests/core/server/test_rate_limits.py

@@ -8,9 +8,9 @@ from chia_rs.sized_ints import uint32
 from chia._tests.conftest import node_with_params
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.protocols.full_node_protocol import RejectBlock, RejectBlocks, RespondBlock, RespondBlocks
+from chia.protocols.outbound_message import make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Capability
-from chia.server.outbound_message import make_msg
 from chia.server.rate_limit_numbers import compose_rate_limits, get_rate_limits_to_use
 from chia.server.rate_limit_numbers import rate_limits as rl_numbers
 from chia.server.rate_limits import RateLimiter

chia/_tests/core/server/test_server.py

@@ -15,11 +15,11 @@ from chia._tests.util.setup_nodes import SimulatorsAndWalletsServices
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.protocols.full_node_protocol import RejectBlock, RequestBlock, RequestTransaction
+from chia.protocols.outbound_message import NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Error, protocol_version
 from chia.protocols.wallet_protocol import RejectHeaderRequest
 from chia.server.api_protocol import ApiMetadata
-from chia.server.outbound_message import NodeType, make_msg
 from chia.server.server import ChiaServer
 from chia.server.start_full_node import create_full_node_service
 from chia.server.start_wallet import create_wallet_service

chia/_tests/core/services/test_services.py

@@ -17,15 +17,15 @@ from typing_extensions import Protocol
 from chia._tests.core.data_layer.util import ChiaRoot
 from chia._tests.util.misc import closing_chia_root_popen
 from chia.daemon.client import DaemonProxy, connect_to_daemon_and_validate
-from chia.rpc.data_layer_rpc_client import DataLayerRpcClient
-from chia.rpc.farmer_rpc_client import FarmerRpcClient
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
-from chia.rpc.harvester_rpc_client import HarvesterRpcClient
+from chia.data_layer.data_layer_rpc_client import DataLayerRpcClient
+from chia.farmer.farmer_rpc_client import FarmerRpcClient
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
+from chia.harvester.harvester_rpc_client import HarvesterRpcClient
 from chia.rpc.rpc_client import RpcClient
-from chia.rpc.wallet_rpc_client import WalletRpcClient
 from chia.simulator.socket import find_available_listen_port
 from chia.util.config import lock_and_load_config, save_config
 from chia.util.timing import adjusted_timeout
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 
 if sys.platform == "win32" or sys.platform == "cygwin":
     termination_signals = [signal.SIGBREAK, signal.SIGINT, signal.SIGTERM]

chia/_tests/core/ssl/test_ssl.py

@@ -10,8 +10,8 @@ import pytest
 from chia_rs.sized_bytes import bytes32
 
 from chia.apis import ApiProtocolRegistry
+from chia.protocols.outbound_message import NodeType
 from chia.protocols.shared_protocol import default_capabilities
-from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer, ssl_context_for_client
 from chia.server.ssl_context import chia_ssl_ca_paths, private_ssl_ca_paths
 from chia.server.ws_connection import WSChiaConnection