chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7__py3-none-any.whl

chia/_tests/core/mempool/test_mempool_manager.py

@@ -32,10 +32,8 @@ from chia.consensus.condition_costs import ConditionCost
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.eligible_coin_spends import (
     DedupCoinSpend,
-    EligibilityAndAdditions,
     IdenticalSpendDedup,
     SkipDedup,
-    run_for_cost,
 )
 from chia.full_node.mempool import MAX_SKIPPED_ITEMS, PRIORITY_TX_THRESHOLD
 from chia.full_node.mempool_manager import (
@@ -280,11 +278,13 @@ async def setup_mempool_with_coins(
     max_block_clvm_cost: Optional[int] = None,
     max_tx_clvm_cost: Optional[uint64] = None,
     mempool_block_buffer: Optional[int] = None,
+    puzzle_hash: bytes32 = IDENTITY_PUZZLE_HASH,
+    height: uint32 = TEST_HEIGHT,
 ) -> tuple[MempoolManager, list[Coin]]:
     coins = []
     test_coin_records = {}
     for amount in coin_amounts:
-        coin = Coin(IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, uint64(amount))
+        coin = Coin(bytes32.random(), puzzle_hash, uint64(amount))
         coins.append(coin)
         test_coin_records[coin.name()] = CoinRecord(coin, uint32(0), uint32(0), False, uint64(0))
 
@@ -302,7 +302,7 @@ async def setup_mempool_with_coins(
     if mempool_block_buffer is not None:
         constants = constants.replace(MEMPOOL_BLOCK_BUFFER=uint8(mempool_block_buffer))
     mempool_manager = await instantiate_mempool_manager(
-        get_coin_records, constants=constants, max_tx_clvm_cost=max_tx_clvm_cost
+        get_coin_records, block_height=height, constants=constants, max_tx_clvm_cost=max_tx_clvm_cost
     )
     return (mempool_manager, coins)
 
@@ -361,6 +361,7 @@ def make_test_conds(
                 flags,
                 execution_cost=0,
                 condition_cost=0,
+                fingerprint=b"",
             )
             for coin_id, parent_id, puzzle_hash, amount, flags, create_coin in spend_info
         ],
@@ -376,6 +377,9 @@ def make_test_conds(
         False,
         0,
         0,
+        0,
+        0,
+        0,
     )
 
 
@@ -559,44 +563,43 @@ def make_bundle_spends_map_and_fee(
     spend_bundle: SpendBundle, conds: SpendBundleConditions
 ) -> tuple[dict[bytes32, BundleCoinSpend], uint64]:
     bundle_coin_spends: dict[bytes32, BundleCoinSpend] = {}
-    eligibility_and_additions: dict[bytes32, EligibilityAndAdditions] = {}
+
+    spend_conditions = {bytes32(spend.coin_id): spend for spend in conds.spends}
+
     removals_amount = 0
     additions_amount = 0
-    for spend in conds.spends:
-        coin_id = bytes32(spend.coin_id)
-        spend_additions = []
-        for puzzle_hash, amount, _ in spend.create_coin:
-            spend_additions.append(Coin(coin_id, puzzle_hash, uint64(amount)))
-            additions_amount += amount
-        eligibility_and_additions[coin_id] = EligibilityAndAdditions(
-            is_eligible_for_dedup=bool(spend.flags & ELIGIBLE_FOR_DEDUP),
-            spend_additions=spend_additions,
-            ff_puzzle_hash=bytes32(spend.puzzle_hash) if bool(spend.flags & ELIGIBLE_FOR_FF) else None,
-        )
     for coin_spend in spend_bundle.coin_spends:
         coin_id = coin_spend.coin.name()
         removals_amount += coin_spend.coin.amount
-        eligibility_info = eligibility_and_additions.get(
-            coin_id, EligibilityAndAdditions(is_eligible_for_dedup=False, spend_additions=[], ff_puzzle_hash=None)
-        )
+        spend_conds = spend_conditions.pop(coin_id)
+
+        additions = []
+        for puzzle_hash, amount, _ in spend_conds.create_coin:
+            additions.append(Coin(coin_id, puzzle_hash, uint64(amount)))
+            additions_amount += amount
+
         bundle_coin_spends[coin_id] = BundleCoinSpend(
             coin_spend=coin_spend,
-            eligible_for_dedup=eligibility_info.is_eligible_for_dedup,
-            eligible_for_fast_forward=eligibility_info.ff_puzzle_hash is not None,
-            additions=eligibility_info.spend_additions,
+            eligible_for_dedup=bool(spend_conds.flags & ELIGIBLE_FOR_DEDUP),
+            additions=additions,
+            cost=uint64(spend_conds.condition_cost + spend_conds.execution_cost),
             latest_singleton_lineage=UnspentLineageInfo(coin_id, coin_spend.coin.parent_coin_info, bytes32([0] * 32))
-            if eligibility_info.ff_puzzle_hash is not None
+            if bool(spend_conds.flags & ELIGIBLE_FOR_FF)
             else None,
         )
+    assert additions_amount == conds.addition_amount
+    assert removals_amount == conds.removal_amount
     fee = uint64(removals_amount - additions_amount)
     return bundle_coin_spends, fee
 
 
 def mempool_item_from_spendbundle(spend_bundle: SpendBundle) -> MempoolItem:
-    conds = get_conditions_from_spendbundle(spend_bundle, INFINITE_COST, DEFAULT_CONSTANTS, uint32(0))
+    conds = get_conditions_from_spendbundle(
+        spend_bundle, INFINITE_COST, DEFAULT_CONSTANTS, DEFAULT_CONSTANTS.HARD_FORK2_HEIGHT
+    )
     bundle_coin_spends, fee = make_bundle_spends_map_and_fee(spend_bundle, conds)
     return MempoolItem(
-        spend_bundle=spend_bundle,
+        aggregated_signature=spend_bundle.aggregated_signature,
         fee=fee,
         conds=conds,
         spend_bundle_name=spend_bundle.name(),
@@ -888,8 +891,13 @@ def mk_bcs(coin_spend: CoinSpend, flags: int = 0) -> BundleCoinSpend:
     return BundleCoinSpend(
         coin_spend=coin_spend,
         eligible_for_dedup=bool(flags & ELIGIBLE_FOR_DEDUP),
-        eligible_for_fast_forward=bool(flags & ELIGIBLE_FOR_FF),
         additions=[],
+        cost=uint64(0),
+        latest_singleton_lineage=UnspentLineageInfo(
+            coin_spend.coin.name(), coin_spend.coin.parent_coin_info, bytes32([0] * 32)
+        )
+        if flags & ELIGIBLE_FOR_FF
+        else None,
     )
 
 
@@ -921,7 +929,7 @@ def mk_item(
     spend_bundle = SpendBundle(coin_spends, G2Element())
     conds = make_test_conds(cost=cost, spend_ids=spend_ids)
     return MempoolItem(
-        spend_bundle=spend_bundle,
+        aggregated_signature=spend_bundle.aggregated_signature,
         fee=uint64(fee),
         conds=conds,
         spend_bundle_name=spend_bundle.name(),
@@ -1116,8 +1124,7 @@ coins = make_test_coins()
     ],
 )
 def test_can_replace(existing_items: list[MempoolItem], new_item: MempoolItem, expected: bool) -> None:
-    removals = {c.name() for c in new_item.spend_bundle.removals()}
-    assert can_replace(existing_items, removals, new_item) == expected
+    assert can_replace(existing_items, new_item) == expected
 
 
 @pytest.mark.anyio
@@ -1583,21 +1590,6 @@ async def test_replacing_one_with_an_eligible_coin() -> None:
     assert_sb_in_pool(mempool_manager, sb123e4)
 
 
-@pytest.mark.parametrize("amount", [0, 1])
-def test_run_for_cost(amount: int) -> None:
-    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, amount]]
-    solution = SerializedProgram.to(conditions)
-    cost = run_for_cost(IDENTITY_PUZZLE, solution, additions_count=1, max_cost=uint64(10000000))
-    assert cost == uint64(1800044)
-
-
-def test_run_for_cost_max_cost() -> None:
-    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
-    solution = SerializedProgram.to(conditions)
-    with pytest.raises(ValueError, match="cost exceeded"):
-        run_for_cost(IDENTITY_PUZZLE, solution, additions_count=1, max_cost=uint64(43))
-
-
 def test_dedup_info_nothing_to_do() -> None:
     # No eligible coins, nothing to deduplicate, item gets considered normally
 
@@ -1613,7 +1605,7 @@ def test_dedup_info_nothing_to_do() -> None:
     mempool_item = mempool_item_from_spendbundle(sb)
     dedup_coin_spends = IdenticalSpendDedup()
     unique_coin_spends, cost_saving, unique_additions = dedup_coin_spends.get_deduplication_info(
-        bundle_coin_spends=mempool_item.bundle_coin_spends, max_cost=mempool_item.conds.cost
+        bundle_coin_spends=mempool_item.bundle_coin_spends
     )
     assert unique_coin_spends == sb.coin_spends
     assert cost_saving == 0
@@ -1633,7 +1625,7 @@ def test_dedup_info_eligible_1st_time() -> None:
     dedup_coin_spends = IdenticalSpendDedup()
     solution = SerializedProgram.to(conditions)
     unique_coin_spends, cost_saving, unique_additions = dedup_coin_spends.get_deduplication_info(
-        bundle_coin_spends=mempool_item.bundle_coin_spends, max_cost=mempool_item.conds.cost
+        bundle_coin_spends=mempool_item.bundle_coin_spends
     )
     assert unique_coin_spends == sb.coin_spends
     assert cost_saving == 0
@@ -1641,7 +1633,10 @@ def test_dedup_info_eligible_1st_time() -> None:
         Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(1)),
         Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(TEST_COIN_AMOUNT - 1)),
     }
-    assert dedup_coin_spends == IdenticalSpendDedup({TEST_COIN_ID: DedupCoinSpend(solution=solution, cost=None)})
+    expected_cost = mempool_item.bundle_coin_spends[TEST_COIN_ID].cost
+    assert dedup_coin_spends == IdenticalSpendDedup(
+        {TEST_COIN_ID: DedupCoinSpend(solution=solution, cost=expected_cost)}
+    )
 
 
 def test_dedup_info_eligible_but_different_solution() -> None:
@@ -1651,14 +1646,12 @@ def test_dedup_info_eligible_but_different_solution() -> None:
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT],
     ]
     initial_solution = SerializedProgram.to(initial_conditions)
-    dedup_coin_spends = IdenticalSpendDedup({TEST_COIN_ID: DedupCoinSpend(solution=initial_solution, cost=None)})
+    dedup_coin_spends = IdenticalSpendDedup({TEST_COIN_ID: DedupCoinSpend(solution=initial_solution, cost=uint64(10))})
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT]]
     sb = spend_bundle_from_conditions(conditions, TEST_COIN)
     mempool_item = mempool_item_from_spendbundle(sb)
     with pytest.raises(SkipDedup, match="Solution is different from what we're deduplicating on"):
-        dedup_coin_spends.get_deduplication_info(
-            bundle_coin_spends=mempool_item.bundle_coin_spends, max_cost=mempool_item.conds.cost
-        )
+        dedup_coin_spends.get_deduplication_info(bundle_coin_spends=mempool_item.bundle_coin_spends)
 
 
 def test_dedup_info_eligible_2nd_time_and_another_1st_time() -> None:
@@ -1668,7 +1661,10 @@ def test_dedup_info_eligible_2nd_time_and_another_1st_time() -> None:
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT - 1],
     ]
     initial_solution = SerializedProgram.to(initial_conditions)
-    dedup_coin_spends = IdenticalSpendDedup({TEST_COIN_ID: DedupCoinSpend(solution=initial_solution, cost=None)})
+    test_coin_cost = uint64(1337)
+    dedup_coin_spends = IdenticalSpendDedup(
+        {TEST_COIN_ID: DedupCoinSpend(solution=initial_solution, cost=test_coin_cost)}
+    )
     sb1 = spend_bundle_from_conditions(initial_conditions, TEST_COIN)
     second_conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT2]]
     second_solution = SerializedProgram.to(second_conditions)
@@ -1677,19 +1673,19 @@ def test_dedup_info_eligible_2nd_time_and_another_1st_time() -> None:
     mempool_item = mempool_item_from_spendbundle(sb)
     assert mempool_item.conds is not None
     unique_coin_spends, cost_saving, unique_additions = dedup_coin_spends.get_deduplication_info(
-        bundle_coin_spends=mempool_item.bundle_coin_spends, max_cost=mempool_item.conds.cost
+        bundle_coin_spends=mempool_item.bundle_coin_spends
     )
     # Only the eligible one that we encountered more than once gets deduplicated
     assert unique_coin_spends == sb2.coin_spends
-    saved_cost = uint64(3600044)
-    assert cost_saving == saved_cost
+    assert cost_saving == test_coin_cost
     assert unique_additions == [Coin(TEST_COIN_ID2, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT2)]
-    # The coin we encountered a second time has its cost and additions properly updated
-    # The coin we encountered for the first time gets cost None and an empty set of additions
+    # The coin we encountered a second time is already in the map
+    # The coin we encountered for the first time gets added with its solution and cost
+    test_coin2_cost = mempool_item.bundle_coin_spends[TEST_COIN_ID2].cost
     expected_dedup_coin_spends = IdenticalSpendDedup(
         {
-            TEST_COIN_ID: DedupCoinSpend(solution=initial_solution, cost=saved_cost),
-            TEST_COIN_ID2: DedupCoinSpend(solution=second_solution, cost=None),
+            TEST_COIN_ID: DedupCoinSpend(solution=initial_solution, cost=test_coin_cost),
+            TEST_COIN_ID2: DedupCoinSpend(solution=second_solution, cost=test_coin2_cost),
         }
     )
     assert dedup_coin_spends == expected_dedup_coin_spends
@@ -1704,11 +1700,12 @@ def test_dedup_info_eligible_3rd_time_another_2nd_time_and_one_non_eligible() ->
     initial_solution = SerializedProgram.to(initial_conditions)
     second_conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT2]]
     second_solution = SerializedProgram.to(second_conditions)
-    saved_cost = uint64(3600044)
+    test_coin_cost = uint64(42)
+    test_coin2_cost = uint64(1337)
     dedup_coin_spends = IdenticalSpendDedup(
         {
-            TEST_COIN_ID: DedupCoinSpend(solution=initial_solution, cost=saved_cost),
-            TEST_COIN_ID2: DedupCoinSpend(solution=second_solution, cost=None),
+            TEST_COIN_ID: DedupCoinSpend(solution=initial_solution, cost=test_coin_cost),
+            TEST_COIN_ID2: DedupCoinSpend(solution=second_solution, cost=test_coin2_cost),
         }
     )
     sb1 = spend_bundle_from_conditions(initial_conditions, TEST_COIN)
@@ -1725,16 +1722,16 @@ def test_dedup_info_eligible_3rd_time_another_2nd_time_and_one_non_eligible() ->
     mempool_item = mempool_item_from_spendbundle(sb)
     assert mempool_item.conds is not None
     unique_coin_spends, cost_saving, unique_additions = dedup_coin_spends.get_deduplication_info(
-        bundle_coin_spends=mempool_item.bundle_coin_spends, max_cost=mempool_item.conds.cost
+        bundle_coin_spends=mempool_item.bundle_coin_spends
     )
     assert unique_coin_spends == sb3.coin_spends
-    saved_cost2 = uint64(1800044)
-    assert cost_saving == saved_cost + saved_cost2
+    assert cost_saving == test_coin_cost + test_coin2_cost
     assert unique_additions == [Coin(TEST_COIN_ID3, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT3)]
+    # TEST_COIN_ID3 is non-eligible, so it doesn't end up in this map
     expected_dedup_coin_spends = IdenticalSpendDedup(
         {
-            TEST_COIN_ID: DedupCoinSpend(initial_solution, saved_cost),
-            TEST_COIN_ID2: DedupCoinSpend(second_solution, saved_cost2),
+            TEST_COIN_ID: DedupCoinSpend(initial_solution, test_coin_cost),
+            TEST_COIN_ID2: DedupCoinSpend(second_solution, test_coin2_cost),
         }
     )
     assert dedup_coin_spends == expected_dedup_coin_spends
@@ -1804,18 +1801,21 @@ async def test_bundle_coin_spends() -> None:
     await send_spendbundle(mempool_manager, sb123e)
     mi123e = mempool_manager.get_mempool_item(sb123e.name())
     assert mi123e is not None
+    execution_cost = 44
     for i in range(3):
         assert mi123e.bundle_coin_spends[coins[i].name()] == BundleCoinSpend(
             coin_spend=sb123.coin_spends[i],
             eligible_for_dedup=False,
-            eligible_for_fast_forward=False,
             additions=[Coin(coins[i].name(), IDENTITY_PUZZLE_HASH, coins[i].amount)],
+            cost=uint64(ConditionCost.CREATE_COIN.value + ConditionCost.AGG_SIG.value + execution_cost),
+            latest_singleton_lineage=None,
         )
     assert mi123e.bundle_coin_spends[coins[3].name()] == BundleCoinSpend(
         coin_spend=eligible_sb.coin_spends[0],
         eligible_for_dedup=True,
-        eligible_for_fast_forward=False,
         additions=[Coin(coins[3].name(), IDENTITY_PUZZLE_HASH, coins[3].amount)],
+        cost=uint64(ConditionCost.CREATE_COIN.value + execution_cost),
+        latest_singleton_lineage=None,
     )
 
 
@@ -2467,7 +2467,7 @@ async def test_new_peak_ff_eviction(
     item = mempool_manager.get_mempool_item(bundle.name())
     assert item is not None
     singleton_name = singleton_spend.coin.name()
-    assert item.bundle_coin_spends[singleton_name].eligible_for_fast_forward
+    assert item.bundle_coin_spends[singleton_name].supports_fast_forward
     latest_singleton_lineage = item.bundle_coin_spends[singleton_name].latest_singleton_lineage
     assert latest_singleton_lineage is not None
     assert latest_singleton_lineage.coin_id == singleton_name
@@ -2499,7 +2499,7 @@ async def test_new_peak_ff_eviction(
     else:
         item = mempool_manager.get_mempool_item(bundle.name())
         assert item is not None
-        assert item.bundle_coin_spends[singleton_spend.coin.name()].eligible_for_fast_forward
+        assert item.bundle_coin_spends[singleton_spend.coin.name()].supports_fast_forward
         latest_singleton_lineage = item.bundle_coin_spends[singleton_spend.coin.name()].latest_singleton_lineage
         assert latest_singleton_lineage is not None
         assert latest_singleton_lineage.coin_id == singleton_spend.coin.name()
@@ -2556,9 +2556,9 @@ async def test_multiple_ff(use_optimization: bool) -> None:
 
     item = mempool_manager.get_mempool_item(bundle.name())
     assert item is not None
-    assert item.bundle_coin_spends[singleton_spend1.coin.name()].eligible_for_fast_forward
-    assert item.bundle_coin_spends[singleton_spend2.coin.name()].eligible_for_fast_forward
-    assert not item.bundle_coin_spends[coin_spend.coin.name()].eligible_for_fast_forward
+    assert item.bundle_coin_spends[singleton_spend1.coin.name()].supports_fast_forward
+    assert item.bundle_coin_spends[singleton_spend2.coin.name()].supports_fast_forward
+    assert not item.bundle_coin_spends[coin_spend.coin.name()].supports_fast_forward
 
     # spend the singleton coin2 and make coin3 the latest version
     coins.update_lineage(singleton_ph, singleton_spend3.coin)
@@ -2620,7 +2620,7 @@ async def test_advancing_ff(use_optimization: bool) -> None:
     item = mempool_manager.get_mempool_item(bundle.name())
     assert item is not None
     spend = item.bundle_coin_spends[spend_a.coin.name()]
-    assert spend.eligible_for_fast_forward
+    assert spend.supports_fast_forward
     assert spend.latest_singleton_lineage is not None
     assert spend.latest_singleton_lineage.coin_id == spend_a.coin.name()
 
@@ -2632,7 +2632,7 @@ async def test_advancing_ff(use_optimization: bool) -> None:
     item = mempool_manager.get_mempool_item(bundle.name())
     assert item is not None
     spend = item.bundle_coin_spends[spend_a.coin.name()]
-    assert spend.eligible_for_fast_forward
+    assert spend.supports_fast_forward
     assert spend.latest_singleton_lineage is not None
     assert spend.latest_singleton_lineage.coin_id == spend_b.coin.name()
 
@@ -2644,7 +2644,7 @@ async def test_advancing_ff(use_optimization: bool) -> None:
     item = mempool_manager.get_mempool_item(bundle.name())
     assert item is not None
     spend = item.bundle_coin_spends[spend_a.coin.name()]
-    assert spend.eligible_for_fast_forward
+    assert spend.supports_fast_forward
     assert spend.latest_singleton_lineage is not None
     assert spend.latest_singleton_lineage.coin_id == spend_c.coin.name()
 
@@ -3163,6 +3163,120 @@ def test_check_removals(case: CheckRemovalsCase) -> None:
     assert set(conflicts) == set(expected_conflicts)
 
 
+# this puzzle just creates coins, however many are requested by the solution
+# (mod (A)
+#    (defun loop (n)
+#        (if (= n 1)
+#            (list)
+#            (c (list 51 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff n) (loop (- n 1))))
+#    )
+#    (loop A)
+# )
+create_coins_loop: str = (
+    "ff02ffff01ff02ff02ffff04ff02ffff04ff05ff80808080ffff04ffff01ff02"
+    "ffff03ffff09ff05ffff010180ff80ffff01ff04ffff04ffff0133ffff04ffff"
+    "01a0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+    "ffffffff04ff05ff80808080ffff02ff02ffff04ff02ffff04ffff11ff05ffff"
+    "010180ff808080808080ff0180ff018080"
+)
+
+# (mod (A)
+#   (defun loop (n)
+#     (if (= n 0) (list) (c n (loop (- n 1))))
+#   )
+#   (c (c 1 (loop A)) ())
+# )
+deep_recursion: str = (
+    "ff02ffff01ff04ffff04ffff0101ffff02ff02ffff04ff02ffff04ff05ff8080"
+    "808080ff8080ffff04ffff01ff02ffff03ffff09ff05ff8080ff80ffff01ff04"
+    "ff05ffff02ff02ffff04ff02ffff04ffff11ff05ffff010180ff808080808080"
+    "ff0180ff018080"
+)
+
+
+# this test uses artificial puzzles just to exercise the block creation. These
+# spends are expected not to verify any signatures
+# This is to keep the test simple.
+@pytest.mark.parametrize(
+    "puzzle, solution",
+    [
+        pytest.param(create_coins_loop, "ff8207d180", id="2000-coins"),
+        pytest.param(create_coins_loop, "ff8203e980", id="1000-coins"),
+        pytest.param(create_coins_loop, "ff8201f580", id="500 coins"),
+        pytest.param(deep_recursion, "ff830f424080", id="recurse-1000000"),
+        pytest.param(deep_recursion, "ff82271080", id="recurse-10000"),
+        pytest.param(deep_recursion, "ff6480", id="recurse-100"),
+    ],
+)
+@pytest.mark.parametrize("old", [True, False])
+@pytest.mark.anyio
+async def test_create_block_generator_custom_spend(
+    puzzle: str, solution: str, old: bool, softfork_height: uint32
+) -> None:
+    solution_str = SerializedProgram.fromhex(solution)
+    puzzle_reveal = SerializedProgram.fromhex(puzzle)
+    puzzle_hash = puzzle_reveal.get_tree_hash()
+
+    mempool_manager, coins = await setup_mempool_with_coins(
+        coin_amounts=list(range(100000000, 100000022)), puzzle_hash=puzzle_hash, height=softfork_height
+    )
+
+    spend_bundles = [
+        SpendBundle(
+            coin_spends=[CoinSpend(coin, puzzle_reveal=puzzle_reveal, solution=solution_str)],
+            aggregated_signature=G2Element(),
+        )
+        for coin in coins
+    ]
+
+    for sb in spend_bundles:
+        try:
+            conds2 = await mempool_manager.pre_validate_spendbundle(sb)
+            await mempool_manager.add_spend_bundle(sb, conds2, sb.name(), softfork_height)
+            invariant_check_mempool(mempool_manager.mempool)
+        except Exception as e:
+            print(f"not adding bundle: {e}")
+            # we don't expect this coin to be spent by the resulting generator
+            # so remove it from the list
+            for cs in sb.coin_spends:
+                coins.remove(cs.coin)
+
+    create_block = mempool_manager.create_block_generator if old else mempool_manager.create_block_generator2
+    assert mempool_manager.peak is not None
+    generator = create_block(mempool_manager.peak.header_hash, 10.0)
+
+    if len(coins) == 0:
+        assert generator is None
+    else:
+        assert generator is not None
+
+        assert generator.signature == G2Element()
+
+        removals = set(generator.removals)
+
+        err, conds = run_block_generator2(
+            bytes(generator.program),
+            generator.generator_refs,
+            DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
+            0,
+            generator.signature,
+            None,
+            DEFAULT_CONSTANTS,
+        )
+
+        assert err is None
+        assert conds is not None
+
+        assert len(conds.spends) == len(removals)
+
+        for spend in conds.spends:
+            removal = Coin(spend.parent_id, spend.puzzle_hash, uint64(spend.coin_amount))
+            assert removal in coins
+            assert removal in removals
+
+    invariant_check_mempool(mempool_manager.mempool)
+
+
 @pytest.mark.anyio
 async def test_new_peak_deferred_ff_items() -> None:
     """
@@ -3269,3 +3383,64 @@ async def test_different_ff_versions() -> None:
     latest_singleton_lineage2 = new_mi2.bundle_coin_spends[version2_id].latest_singleton_lineage
     assert latest_singleton_lineage2 is not None
     assert latest_singleton_lineage2.coin_id == new_latest_lineage_id
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "condition_and_error",
+    [
+        (ConditionOpcode.ASSERT_HEIGHT_RELATIVE, Err.ASSERT_HEIGHT_RELATIVE_FAILED),
+        (ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, Err.ASSERT_HEIGHT_ABSOLUTE_FAILED),
+    ],
+)
+@pytest.mark.parametrize("optimized_path", [True, False])
+async def test_new_peak_txs_added(condition_and_error: tuple[ConditionOpcode, Err], optimized_path: bool) -> None:
+    """
+    Tests that deferred transactions because of time-lock are retried once the
+    time-lock allows them to be reconsidered.
+    """
+    coins = TestCoins([TEST_COIN], {})
+    mempool_manager = await setup_mempool(coins)
+    # Add an item that should go to the pending cache
+    assert mempool_manager.peak is not None
+    condition_height = mempool_manager.peak.height + 1
+    condition, expected_error = condition_and_error
+    _, sb_name, result = await generate_and_add_spendbundle(mempool_manager, [[condition, condition_height]])
+    _, status, error = result
+    assert status == MempoolInclusionStatus.PENDING
+    assert error == expected_error
+    # Advance the mempool beyond the asserted height to retry the test item
+    if optimized_path:
+        spent_coins: Optional[list[bytes32]] = []
+        new_peak_info = await mempool_manager.new_peak(
+            create_test_block_record(height=uint32(condition_height)), spent_coins
+        )
+        # We're not there yet (needs to be higher, not equal)
+        assert new_peak_info.spend_bundle_ids == []
+        assert mempool_manager.get_mempool_item(sb_name, include_pending=False) is None
+    else:
+        spent_coins = None
+    new_peak_info = await mempool_manager.new_peak(
+        create_test_block_record(height=uint32(condition_height + 1)), spent_coins
+    )
+    # The item gets retried successfully now
+    assert new_peak_info.spend_bundle_ids == [sb_name]
+    assert mempool_manager.get_mempool_item(sb_name, include_pending=False) is not None
+
+
+@pytest.mark.anyio
+async def test_mempool_item_to_spend_bundle() -> None:
+    """
+    Tests that we can properly go back to a `SpendBundle` from a `MempoolItem`.
+    """
+    coins = [Coin(bytes32.random(), IDENTITY_PUZZLE_HASH, uint64(i + 1)) for i in range(random.randint(42, 1337))]
+    mempool_manager = await setup_mempool(TestCoins(coins, {}))
+    random_sample = random.sample(coins, 42)
+    sb = SpendBundle([CoinSpend(c, IDENTITY_PUZZLE, SerializedProgram.to(None)) for c in random_sample], G2Element())
+    sb_name = sb.name()
+    await add_spendbundle(mempool_manager, sb, sb_name)
+    mi = mempool_manager.get_mempool_item(sb_name)
+    assert mi is not None
+    result = mi.to_spend_bundle()
+    assert result == sb
+    assert result.name() == sb_name

chia/_tests/core/mempool/test_singleton_fast_forward.py

@@ -52,8 +52,10 @@ def test_process_fast_forward_spends_nothing_to_do() -> None:
     sb = spend_bundle_from_conditions(conditions, TEST_COIN, sig)
     item = mempool_item_from_spendbundle(sb)
     # This coin is not eligible for fast forward
-    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)
+    assert not item.bundle_coin_spends[TEST_COIN_ID].supports_fast_forward
+    internal_mempool_item = InternalMempoolItem(
+        sb.aggregated_signature, item.conds, item.height_added_to_mempool, item.bundle_coin_spends
+    )
     original_version = dataclasses.replace(internal_mempool_item)
     singleton_ff = SingletonFastForward()
     bundle_coin_spends = singleton_ff.process_fast_forward_spends(
@@ -63,28 +65,6 @@ def test_process_fast_forward_spends_nothing_to_do() -> None:
     assert bundle_coin_spends == original_version.bundle_coin_spends
 
 
-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 item's latest singleton lineage
-    """
-    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)
-    singleton_ff = SingletonFastForward()
-    # We have no fast forward records yet, so we'll process this coin for the
-    # first time here, but the item's latest singleton lineage returns None
-    with pytest.raises(ValueError, match="Cannot proceed with singleton spend fast forward."):
-        singleton_ff.process_fast_forward_spends(
-            mempool_item=internal_mempool_item, height=TEST_HEIGHT, constants=DEFAULT_CONSTANTS
-        )
-
-
 def test_process_fast_forward_spends_latest_unspent() -> None:
     """
     This tests the case when we are the latest singleton version already, so
@@ -103,9 +83,11 @@ def test_process_fast_forward_spends_latest_unspent() -> None:
     conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, test_amount]]
     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
+    assert item.bundle_coin_spends[test_coin.name()].supports_fast_forward
     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)
+    internal_mempool_item = InternalMempoolItem(
+        sb.aggregated_signature, item.conds, item.height_added_to_mempool, item.bundle_coin_spends
+    )
     original_version = dataclasses.replace(internal_mempool_item)
     singleton_ff = SingletonFastForward()
     bundle_coin_spends = singleton_ff.process_fast_forward_spends(
@@ -168,12 +150,12 @@ def test_perform_the_fast_forward() -> None:
         "517b0dadb0c310ded24dd86dff8205398080ff808080"
     )
     test_coin_spend = CoinSpend(test_coin, test_puzzle_reveal, test_solution)
-    test_spend_data = BundleCoinSpend(test_coin_spend, False, True, [test_child_coin])
     test_unspent_lineage_info = UnspentLineageInfo(
         coin_id=latest_unspent_coin.name(),
         parent_id=latest_unspent_coin.parent_coin_info,
         parent_parent_id=test_child_coin.parent_coin_info,
     )
+    test_spend_data = BundleCoinSpend(test_coin_spend, False, [test_child_coin], uint64(0), test_unspent_lineage_info)
     # Start from a fresh state of fast forward spends
     fast_forward_spends: dict[bytes32, UnspentLineageInfo] = {}
     # Perform the fast forward on the test coin (the grandparent)

chia/_tests/core/server/serve.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import asyncio.events
-import asyncio.protocols
 import dataclasses
 import functools
 import logging.config