chia-blockchain 2.5.2rc2__py3-none-any.whl → 2.5.3rc2__py3-none-any.whl

chia/_tests/core/mempool/test_mempool_manager.py

@@ -2,18 +2,26 @@ from __future__ import annotations
 
 import dataclasses
 import logging
-from collections.abc import Awaitable, Collection
-from typing import Any, Callable, ClassVar, Optional
+from collections.abc import Awaitable, Collection, Sequence
+from typing import Any, Callable, ClassVar, Optional, Union
 
 import pytest
-from chia_rs import ELIGIBLE_FOR_DEDUP, ELIGIBLE_FOR_FF, AugSchemeMPL, G2Element, get_conditions_from_spendbundle
+from chia_rs import (
+    ELIGIBLE_FOR_DEDUP,
+    ELIGIBLE_FOR_FF,
+    AugSchemeMPL,
+    ConsensusConstants,
+    G2Element,
+    get_conditions_from_spendbundle,
+)
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint32, uint64
 from chiabip158 import PyBIP158
 
 from chia._tests.conftest import ConsensusMode
 from chia._tests.util.misc import invariant_check_mempool
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets, setup_simulators_and_wallets
 from chia.consensus.condition_costs import ConditionCost
-from chia.consensus.constants import ConsensusConstants
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.mempool import MAX_SKIPPED_ITEMS, PRIORITY_TX_THRESHOLD
 from chia.full_node.mempool_check_conditions import mempool_check_time_locks
@@ -36,7 +44,6 @@ from chia.simulator.simulator_protocol import FarmNewBlockProtocol
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import INFINITE_COST, Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.clvm_cost import CLVMCost
 from chia.types.coin_record import CoinRecord
 from chia.types.coin_spend import CoinSpend, make_spend
@@ -45,6 +52,7 @@ from chia.types.eligible_coin_spends import (
     DedupCoinSpend,
     EligibilityAndAdditions,
     EligibleCoinSpends,
+    SkipDedup,
     UnspentLineageInfo,
     run_for_cost,
 )
@@ -54,9 +62,7 @@ from chia.types.peer_info import PeerInfo
 from chia.types.spend_bundle import SpendBundle
 from chia.types.spend_bundle_conditions import SpendBundleConditions, SpendConditions
 from chia.util.errors import Err, ValidationError
-from chia.util.ints import uint8, uint32, uint64
 from chia.wallet.conditions import AssertCoinAnnouncement
-from chia.wallet.payment import Payment
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_coin_record import WalletCoinRecord
@@ -202,15 +208,22 @@ def make_test_conds(
     before_seconds_relative: Optional[int] = None,
     before_seconds_absolute: Optional[int] = None,
     cost: int = 0,
-    spend_ids: list[bytes32] = [TEST_COIN_ID],
+    spend_ids: Sequence[tuple[Union[bytes32, Coin], int]] = [(TEST_COIN_ID, 0)],
 ) -> SpendBundleConditions:
+    spend_info: list[tuple[bytes32, bytes32, bytes32, uint64, int]] = []
+    for coin, flags in spend_ids:
+        if isinstance(coin, Coin):
+            spend_info.append((coin.name(), coin.parent_coin_info, coin.puzzle_hash, coin.amount, flags))
+        else:
+            spend_info.append((coin, IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT, flags))
+
     return SpendBundleConditions(
         [
             SpendConditions(
-                spend_id,
-                IDENTITY_PUZZLE_HASH,
-                IDENTITY_PUZZLE_HASH,
-                TEST_COIN_AMOUNT,
+                coin_id,
+                parent_id,
+                puzzle_hash,
+                amount,
                 None if height_relative is None else uint32(height_relative),
                 None if seconds_relative is None else uint64(seconds_relative),
                 None if before_height_relative is None else uint32(before_height_relative),
@@ -225,9 +238,9 @@ def make_test_conds(
                 [],
                 [],
                 [],
-                0,
+                flags,
             )
-            for spend_id in spend_ids
+            for coin_id, parent_id, puzzle_hash, amount, flags in spend_info
         ],
         0,
         uint32(height_absolute),
@@ -746,19 +759,25 @@ def mk_item(
     assert_height: Optional[int] = None,
     assert_before_height: Optional[int] = None,
     assert_before_seconds: Optional[int] = None,
+    flags: list[int] = [],
 ) -> MempoolItem:
     # we don't actually care about the puzzle and solutions for the purpose of
     # can_replace()
-    spend_ids = []
+    spend_ids: list[tuple[bytes32, int]] = []
     coin_spends = []
     bundle_coin_spends = {}
-    for c in coins:
+    if len(flags) < len(coins):
+        flags.extend([0] * (len(coins) - len(flags)))
+    for c, f in zip(coins, flags):
         coin_id = c.name()
-        spend_ids.append(coin_id)
+        spend_ids.append((coin_id, f))
         spend = make_spend(c, SerializedProgram.to(None), SerializedProgram.to(None))
         coin_spends.append(spend)
         bundle_coin_spends[coin_id] = BundleCoinSpend(
-            coin_spend=spend, eligible_for_dedup=False, eligible_for_fast_forward=False, additions=[]
+            coin_spend=spend,
+            eligible_for_dedup=bool(f & ELIGIBLE_FOR_DEDUP),
+            eligible_for_fast_forward=bool(f & ELIGIBLE_FOR_FF),
+            additions=[],
         )
     spend_bundle = SpendBundle(coin_spends, G2Element())
     conds = make_test_conds(cost=cost, spend_ids=spend_ids)
@@ -812,6 +831,46 @@ coins = make_test_coins()
         ([mk_item(coins[0:2])], mk_item(coins[0:2], fee=10000000), True),
         # or if we spend the same coins with additional coins
         ([mk_item(coins[0:2])], mk_item(coins[0:3], fee=10000000), True),
+        # you're not allowed to clear the fast-forward or dedup flag. It's OK to set it
+        # and leave it unchanged
+        ([mk_item(coins[0:2])], mk_item(coins[0:3], flags=[ELIGIBLE_FOR_DEDUP, 0, 0], fee=10000000), True),
+        ([mk_item(coins[0:2])], mk_item(coins[0:3], flags=[ELIGIBLE_FOR_FF, 0, 0], fee=10000000), True),
+        # flag cleared
+        ([mk_item(coins[0:2], flags=[ELIGIBLE_FOR_DEDUP, 0])], mk_item(coins[0:3], fee=10000000), False),
+        ([mk_item(coins[0:2], flags=[ELIGIBLE_FOR_FF, 0])], mk_item(coins[0:3], fee=10000000), False),
+        # unchanged
+        (
+            [mk_item(coins[0:2], flags=[ELIGIBLE_FOR_DEDUP, 0])],
+            mk_item(coins[0:3], flags=[ELIGIBLE_FOR_DEDUP, 0, 0], fee=10000000),
+            True,
+        ),
+        (
+            [mk_item(coins[0:2], flags=[ELIGIBLE_FOR_FF, 0])],
+            mk_item(coins[0:3], flags=[ELIGIBLE_FOR_FF, 0, 0], fee=10000000),
+            True,
+        ),
+        # the spends are independent
+        (
+            [mk_item(coins[0:2], flags=[ELIGIBLE_FOR_DEDUP, 0])],
+            mk_item(coins[0:3], flags=[0, ELIGIBLE_FOR_DEDUP, 0], fee=10000000),
+            False,
+        ),
+        (
+            [mk_item(coins[0:2], flags=[ELIGIBLE_FOR_FF, 0])],
+            mk_item(coins[0:3], flags=[0, ELIGIBLE_FOR_FF, 0], fee=10000000),
+            False,
+        ),
+        # the bits are independent
+        (
+            [mk_item(coins[0:2], flags=[ELIGIBLE_FOR_DEDUP, 0])],
+            mk_item(coins[0:3], flags=[ELIGIBLE_FOR_FF, 0, 0], fee=10000000),
+            False,
+        ),
+        (
+            [mk_item(coins[0:2], flags=[ELIGIBLE_FOR_DEDUP, 0])],
+            mk_item(coins[0:3], flags=[ELIGIBLE_FOR_FF, 0, 0], fee=10000000),
+            False,
+        ),
         # FEE- AND FEE RATE RULES
         # if we're replacing two items, each paying a fee of 100, we need to
         # spend (at least) the same coins and pay at least 10000000 higher fee
@@ -1007,9 +1066,6 @@ async def test_total_mempool_fees() -> None:
 @pytest.mark.parametrize("reverse_tx_order", [True, False])
 @pytest.mark.anyio
 async def test_create_bundle_from_mempool(reverse_tx_order: bool) -> None:
-    async def get_unspent_lineage_info_for_puzzle_hash(_: bytes32) -> Optional[UnspentLineageInfo]:
-        assert False  # pragma: no cover
-
     async def make_coin_spends(coins: list[Coin], *, high_fees: bool = True) -> list[CoinSpend]:
         spends_list = []
         for i in range(0, len(coins)):
@@ -1036,9 +1092,7 @@ async def test_create_bundle_from_mempool(reverse_tx_order: bool) -> None:
     spends = low_rate_spends + high_rate_spends if reverse_tx_order else high_rate_spends + low_rate_spends
     await send_spends_to_mempool(spends)
     assert mempool_manager.peak is not None
-    result = await mempool_manager.create_bundle_from_mempool(
-        mempool_manager.peak.header_hash, get_unspent_lineage_info_for_puzzle_hash
-    )
+    result = await mempool_manager.create_bundle_from_mempool(mempool_manager.peak.header_hash)
     assert result is not None
     # Make sure we filled the block with only high rate spends
     assert len([s for s in high_rate_spends if s in result[0].coin_spends]) == len(result[0].coin_spends)
@@ -1057,9 +1111,6 @@ async def test_create_bundle_from_mempool_on_max_cost(num_skipped_items: int, ca
       2. After skipping MAX_SKIPPED_ITEMS, we stop processing further items.
     """
 
-    async def get_unspent_lineage_info_for_puzzle_hash(_: bytes32) -> Optional[UnspentLineageInfo]:
-        assert False  # pragma: no cover
-
     MAX_BLOCK_CLVM_COST = 550_000_000
 
     mempool_manager, coins = await setup_mempool_with_coins(
@@ -1123,7 +1174,7 @@ async def test_create_bundle_from_mempool_on_max_cost(num_skipped_items: int, ca
     g1 = sk.get_g1()
     sig = AugSchemeMPL.sign(sk, b"foobar", g1)
     for i in range(num_skipped_items + 1, num_skipped_items + 5):
-        conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coins[i].amount - 30_000]]
+        conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coins[i].amount]]
         # Make the first of these without eligible coins
         if i == num_skipped_items + 1:
             conditions.append([ConditionOpcode.AGG_SIG_UNSAFE, bytes(g1), b"foobar"])
@@ -1132,22 +1183,17 @@ async def test_create_bundle_from_mempool_on_max_cost(num_skipped_items: int, ca
             aggsig = G2Element()
         sb, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, coins[i], aggsig)
         extra_sbs.append(sb)
-        coin = Coin(coins[i].name(), IDENTITY_PUZZLE_HASH, uint64(coins[i].amount - 30_000))
+        coin = Coin(coins[i].name(), IDENTITY_PUZZLE_HASH, uint64(coins[i].amount))
         extra_additions.append(coin)
         assert res[1] == MempoolInclusionStatus.SUCCESS
 
     assert mempool_manager.peak is not None
     caplog.set_level(logging.DEBUG)
-    result = await mempool_manager.create_bundle_from_mempool(
-        mempool_manager.peak.header_hash, get_unspent_lineage_info_for_puzzle_hash
-    )
+    result = await mempool_manager.create_bundle_from_mempool(mempool_manager.peak.header_hash)
     assert result is not None
     agg, additions = result
     skipped_due_to_eligible_coins = sum(
-        1
-        for line in caplog.text.split("\n")
-        if "Exception while checking a mempool item for deduplication: Skipping transaction with eligible coin(s)"
-        in line
+        1 for line in caplog.text.split("\n") if "Skipping transaction with dedup or FF spends" in line
     )
     if num_skipped_items == PRIORITY_TX_THRESHOLD:
         # We skipped enough big cost items to reach `PRIORITY_TX_THRESHOLD`,
@@ -1440,7 +1486,7 @@ def test_dedup_info_eligible_1st_time() -> None:
     # Eligible coin encountered for the first time
     conditions = [
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1],
-        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 2],
+        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT - 1],
     ]
     sb = spend_bundle_from_conditions(conditions, TEST_COIN)
     mempool_item = mempool_item_from_spendbundle(sb)
@@ -1454,7 +1500,7 @@ def test_dedup_info_eligible_1st_time() -> None:
     assert cost_saving == 0
     assert set(unique_additions) == {
         Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(1)),
-        Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(2)),
+        Coin(TEST_COIN_ID, IDENTITY_PUZZLE_HASH, uint64(TEST_COIN_AMOUNT - 1)),
     }
     assert eligible_coin_spends == EligibleCoinSpends({TEST_COIN_ID: DedupCoinSpend(solution=solution, cost=None)})
 
@@ -1463,14 +1509,14 @@ def test_dedup_info_eligible_but_different_solution() -> None:
     # Eligible coin but different solution from the one we encountered
     initial_conditions = [
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1],
-        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 2],
+        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT],
     ]
     initial_solution = SerializedProgram.to(initial_conditions)
     eligible_coin_spends = EligibleCoinSpends({TEST_COIN_ID: DedupCoinSpend(solution=initial_solution, cost=None)})
-    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 2]]
+    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(ValueError, match="Solution is different from what we're deduplicating on"):
+    with pytest.raises(SkipDedup, match="Solution is different from what we're deduplicating on"):
         eligible_coin_spends.get_deduplication_info(
             bundle_coin_spends=mempool_item.bundle_coin_spends, max_cost=mempool_item.conds.cost
         )
@@ -1480,12 +1526,12 @@ def test_dedup_info_eligible_2nd_time_and_another_1st_time() -> None:
     # Eligible coin encountered a second time, and another for the first time
     initial_conditions = [
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1],
-        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 2],
+        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT - 1],
     ]
     initial_solution = SerializedProgram.to(initial_conditions)
     eligible_coin_spends = EligibleCoinSpends({TEST_COIN_ID: DedupCoinSpend(solution=initial_solution, cost=None)})
     sb1 = spend_bundle_from_conditions(initial_conditions, TEST_COIN)
-    second_conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 3]]
+    second_conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT2]]
     second_solution = SerializedProgram.to(second_conditions)
     sb2 = spend_bundle_from_conditions(second_conditions, TEST_COIN2)
     sb = SpendBundle.aggregate([sb1, sb2])
@@ -1498,7 +1544,7 @@ def test_dedup_info_eligible_2nd_time_and_another_1st_time() -> None:
     assert unique_coin_spends == sb2.coin_spends
     saved_cost = uint64(3600044)
     assert cost_saving == saved_cost
-    assert unique_additions == [Coin(TEST_COIN_ID2, IDENTITY_PUZZLE_HASH, uint64(3))]
+    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
     expected_eligible_spends = EligibleCoinSpends(
@@ -1514,10 +1560,10 @@ def test_dedup_info_eligible_3rd_time_another_2nd_time_and_one_non_eligible() ->
     # Eligible coin encountered a third time, another for the second time and one non eligible
     initial_conditions = [
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1],
-        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 2],
+        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT - 1],
     ]
     initial_solution = SerializedProgram.to(initial_conditions)
-    second_conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 3]]
+    second_conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT2]]
     second_solution = SerializedProgram.to(second_conditions)
     saved_cost = uint64(3600044)
     eligible_coin_spends = EligibleCoinSpends(
@@ -1533,7 +1579,7 @@ def test_dedup_info_eligible_3rd_time_another_2nd_time_and_one_non_eligible() ->
     sig = AugSchemeMPL.sign(sk, b"foobar", g1)
     sb3_conditions = [
         [ConditionOpcode.AGG_SIG_UNSAFE, g1, b"foobar"],
-        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 4],
+        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT3],
     ]
     sb3 = spend_bundle_from_conditions(sb3_conditions, TEST_COIN3, sig)
     sb = SpendBundle.aggregate([sb1, sb2, sb3])
@@ -1545,7 +1591,7 @@ def test_dedup_info_eligible_3rd_time_another_2nd_time_and_one_non_eligible() ->
     assert unique_coin_spends == sb3.coin_spends
     saved_cost2 = uint64(1800044)
     assert cost_saving == saved_cost + saved_cost2
-    assert unique_additions == [Coin(TEST_COIN_ID3, IDENTITY_PUZZLE_HASH, uint64(4))]
+    assert unique_additions == [Coin(TEST_COIN_ID3, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT3)]
     expected_eligible_spends = EligibleCoinSpends(
         {
             TEST_COIN_ID: DedupCoinSpend(initial_solution, saved_cost),
@@ -1581,7 +1627,12 @@ async def test_coin_spending_different_ways_then_finding_it_spent_in_new_peak(ne
     # Create a bunch of mempool items that spend the coin in different ways
     for i in range(3):
         _, _, result = await generate_and_add_spendbundle(
-            mempool_manager, [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, i]], coin
+            mempool_manager,
+            [
+                [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount],
+                [ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, uint64(i)],
+            ],
+            coin,
         )
         assert result[1] == MempoolInclusionStatus.SUCCESS
     assert len(list(mempool_manager.mempool.get_items_by_coin_id(coin_id))) == 3
@@ -1662,11 +1713,10 @@ async def test_identical_spend_aggregation_e2e(
         phs = [await wallet.get_new_puzzlehash() for _ in range(3)]
         for _ in range(2):
             await farm_a_block(full_node_api, wallet_node, ph)
-        other_recipients = [Payment(puzzle_hash=p, amount=uint64(200), memos=[]) for p in phs[1:]]
         async with wallet.wallet_state_manager.new_action_scope(
             DEFAULT_TX_CONFIG, push=False, sign=True
         ) as action_scope:
-            await wallet.generate_signed_transaction(uint64(200), phs[0], action_scope, primaries=other_recipients)
+            await wallet.generate_signed_transaction([uint64(200)] * len(phs), phs, action_scope)
         [tx] = action_scope.side_effects.transactions
         assert tx.spend_bundle is not None
         await send_to_mempool(full_node_api, tx.spend_bundle)
@@ -1685,9 +1735,9 @@ async def test_identical_spend_aggregation_e2e(
     async with wallet.wallet_state_manager.new_action_scope(
         DEFAULT_TX_CONFIG, push=False, merge_spends=False, sign=True
     ) as action_scope:
-        await wallet.generate_signed_transaction(uint64(30), ph, action_scope, coins={coins[0].coin})
-        await wallet.generate_signed_transaction(uint64(30), ph, action_scope, coins={coins[1].coin})
-        await wallet.generate_signed_transaction(uint64(30), ph, action_scope, coins={coins[2].coin})
+        await wallet.generate_signed_transaction([uint64(30)], [ph], action_scope, coins={coins[0].coin})
+        await wallet.generate_signed_transaction([uint64(30)], [ph], action_scope, coins={coins[1].coin})
+        await wallet.generate_signed_transaction([uint64(30)], [ph], action_scope, coins={coins[2].coin})
     [tx_a, tx_b, tx_c] = action_scope.side_effects.transactions
     assert tx_a.spend_bundle is not None
     assert tx_b.spend_bundle is not None
@@ -1705,7 +1755,9 @@ async def test_identical_spend_aggregation_e2e(
     async with wallet.wallet_state_manager.new_action_scope(
         DEFAULT_TX_CONFIG, push=False, merge_spends=False, sign=True
     ) as action_scope:
-        await wallet.generate_signed_transaction(uint64(200), IDENTITY_PUZZLE_HASH, action_scope, coins={coins[3].coin})
+        await wallet.generate_signed_transaction(
+            [uint64(200)], [IDENTITY_PUZZLE_HASH], action_scope, coins={coins[3].coin}
+        )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
     await send_to_mempool(full_node_api, tx.spend_bundle)
@@ -1714,9 +1766,8 @@ async def test_identical_spend_aggregation_e2e(
     coins_with_identity_ph = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(
         False, IDENTITY_PUZZLE_HASH
     )
-    sb = spend_bundle_from_conditions(
-        [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 110]], coins_with_identity_ph[0].coin
-    )
+    coin = coins_with_identity_ph[0].coin
+    sb = spend_bundle_from_conditions([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount]], coin)
     await send_to_mempool(full_node_api, sb)
     await farm_a_block(full_node_api, wallet_node, ph)
     # Grab the eligible coin to spend as E in DE and EF transactions
@@ -1732,16 +1783,16 @@ async def test_identical_spend_aggregation_e2e(
         DEFAULT_TX_CONFIG, push=False, merge_spends=False, sign=True
     ) as action_scope:
         await wallet.generate_signed_transaction(
-            uint64(100),
-            ph,
+            [uint64(100)],
+            [ph],
             action_scope,
             fee=uint64(0),
             coins={coins[4].coin},
             extra_conditions=(e_announcement,),
         )
         await wallet.generate_signed_transaction(
-            uint64(150),
-            ph,
+            [uint64(150)],
+            [ph],
             action_scope,
             fee=uint64(0),
             coins={coins[5].coin},
@@ -1753,7 +1804,7 @@ async def test_identical_spend_aggregation_e2e(
     # Create transaction E now that spends e_coin to create another eligible
     # coin as well as the announcement consumed by D and F
     conditions: list[list[Any]] = [
-        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 42],
+        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, e_coin.amount],
         [ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, message],
     ]
     sb_e = spend_bundle_from_conditions(conditions, e_coin)
@@ -1767,7 +1818,8 @@ async def test_identical_spend_aggregation_e2e(
     # Send also a transaction EG that spends E differently from DE and EF,
     # so that it doesn't get deduplicated on E with them
     conditions = [
-        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, e_coin.amount - 1],
+        [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, e_coin.amount],
+        [ConditionOpcode.ASSERT_MY_COIN_ID, e_coin.name()],
         [ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, message],
     ]
     sb_e2 = spend_bundle_from_conditions(conditions, e_coin)
@@ -1777,7 +1829,7 @@ async def test_identical_spend_aggregation_e2e(
         DEFAULT_TX_CONFIG, push=False, merge_spends=False, sign=True
     ) as action_scope:
         await wallet.generate_signed_transaction(
-            uint64(13), ph, action_scope, coins={g_coin}, extra_conditions=(e_announcement,)
+            [uint64(13)], [ph], action_scope, coins={g_coin}, extra_conditions=(e_announcement,)
         )
     [tx_g] = action_scope.side_effects.transactions
     assert tx_g.spend_bundle is not None
@@ -1808,7 +1860,7 @@ async def test_identical_spend_aggregation_e2e(
         False, IDENTITY_PUZZLE_HASH
     )
     assert len(eligible_coins) == 1
-    assert eligible_coins[0].coin.amount == 42
+    assert eligible_coins[0].coin.amount == e_coin.amount
 
 
 # we have two coins in this test. They have different birth heights (and
@@ -2091,3 +2143,361 @@ async def test_fill_rate_block_validation(
         rb_res_parsed = RespondBlock.from_bytes(rb_res.data)
         assert rb_res_parsed.block.transactions_info is not None
         assert rb_res_parsed.block.transactions_info.cost == expected_block_cost
+
+
+@pytest.mark.parametrize("optimized_path", [True, False])
+@pytest.mark.anyio
+async def test_height_added_to_mempool(optimized_path: bool) -> None:
+    """
+    This test covers scenarios when the mempool is updated or rebuilt, to make
+    sure that mempool items maintain correct height added to mempool values.
+    We control whether we're updating the mempool or rebuilding it, through the
+    `optimized_path` param.
+    """
+    mempool_manager = await instantiate_mempool_manager(get_coin_records_for_test_coins)
+    assert mempool_manager.peak is not None
+    assert mempool_manager.peak.height == TEST_HEIGHT
+    assert mempool_manager.peak.header_hash == height_hash(TEST_HEIGHT)
+    # Create a mempool item and keep track of its height added to mempool
+    _, sb_name, _ = await generate_and_add_spendbundle(
+        mempool_manager, [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1]]
+    )
+    mi = mempool_manager.get_mempool_item(sb_name)
+    assert mi is not None
+    original_height = mi.height_added_to_mempool
+    # Let's get a new peak that doesn't include our item, and make sure the
+    # height added to mempool remains correct.
+    test_new_peak = TestBlockRecord(
+        header_hash=height_hash(TEST_HEIGHT + 1),
+        height=uint32(TEST_HEIGHT + 1),
+        timestamp=uint64(TEST_TIMESTAMP + 42),
+        prev_transaction_block_height=TEST_HEIGHT,
+        prev_transaction_block_hash=height_hash(TEST_HEIGHT),
+    )
+    if optimized_path:
+        # Spend an unrelated coin to get the mempool updated
+        spent_coins = [TEST_COIN_ID2]
+    else:
+        # Trigger the slow path to get the mempool rebuilt
+        spent_coins = None
+    await mempool_manager.new_peak(test_new_peak, spent_coins)
+    assert mempool_manager.peak.height == TEST_HEIGHT + 1
+    assert mempool_manager.peak.header_hash == height_hash(TEST_HEIGHT + 1)
+    # Make sure our item is still in the mempool, and that its height added to
+    # mempool value is still correct.
+    mempool_item = mempool_manager.get_mempool_item(sb_name)
+    assert mempool_item is not None
+    assert mempool_item.height_added_to_mempool == original_height
+
+
+# This is a test utility to provide a simple view of the coin table for the
+# mempool manager.
+class TestCoins:
+    coin_records: dict[bytes32, CoinRecord]
+    lineage_info: dict[bytes32, UnspentLineageInfo]
+
+    def __init__(self, coins: list[Coin], lineage: dict[bytes32, Coin]) -> None:
+        self.coin_records = {}
+        for c in coins:
+            self.coin_records[c.name()] = CoinRecord(c, uint32(0), uint32(0), False, TEST_TIMESTAMP)
+        self.lineage_info = {}
+        for ph, c in lineage.items():
+            self.lineage_info[ph] = UnspentLineageInfo(
+                c.name(), c.amount, c.parent_coin_info, uint64(1337), bytes32([42] * 32)
+            )
+
+    def spend_coin(self, coin_id: bytes32, height: uint32 = uint32(10)) -> None:
+        self.coin_records[coin_id] = dataclasses.replace(self.coin_records[coin_id], spent_block_index=height)
+
+    def update_lineage(self, puzzle_hash: bytes32, coin: Optional[Coin]) -> None:
+        if coin is None:
+            self.lineage_info.pop(puzzle_hash)
+        else:
+            assert coin.puzzle_hash == puzzle_hash
+            prev = self.lineage_info[puzzle_hash]
+            self.lineage_info[puzzle_hash] = UnspentLineageInfo(
+                coin.name(), coin.amount, coin.parent_coin_info, prev.coin_amount, prev.coin_id
+            )
+
+    async def get_coin_records(self, coin_ids: Collection[bytes32]) -> list[CoinRecord]:
+        ret = []
+        for coin_id in coin_ids:
+            rec = self.coin_records.get(coin_id)
+            if rec is not None:
+                ret.append(rec)
+
+        return ret
+
+    async def get_unspent_lineage_info(self, ph: bytes32) -> Optional[UnspentLineageInfo]:
+        return self.lineage_info.get(ph)
+
+
+# creates a CoinSpend of a made up
+def make_singleton_spend(launcher_id: bytes32, parent_parent_id: bytes32 = bytes32([3] * 32)) -> CoinSpend:
+    from chia_rs import supports_fast_forward
+
+    from chia.wallet.lineage_proof import LineageProof
+    from chia.wallet.puzzles.singleton_top_layer_v1_1 import (
+        puzzle_for_singleton,
+        solution_for_singleton,
+    )
+
+    singleton_puzzle = SerializedProgram.from_program(puzzle_for_singleton(launcher_id, Program.to(1)))
+
+    PARENT_COIN = Coin(parent_parent_id, singleton_puzzle.get_tree_hash(), uint64(1))
+    COIN = Coin(PARENT_COIN.name(), singleton_puzzle.get_tree_hash(), uint64(1))
+
+    lineage_proof = LineageProof(parent_parent_id, IDENTITY_PUZZLE_HASH, uint64(1))
+
+    inner_solution = Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, uint64(1)]])
+    singleton_solution = SerializedProgram.from_program(
+        solution_for_singleton(lineage_proof, uint64(1), inner_solution)
+    )
+
+    ret = CoinSpend(COIN, singleton_puzzle, singleton_solution)
+
+    # we make sure the spend actually supports fast forward
+    assert supports_fast_forward(ret)
+    assert ret.coin.puzzle_hash == ret.puzzle_reveal.get_tree_hash()
+    return ret
+
+
+async def setup_mempool(coins: TestCoins) -> MempoolManager:
+    mempool_manager = MempoolManager(
+        coins.get_coin_records,
+        coins.get_unspent_lineage_info,
+        DEFAULT_CONSTANTS,
+    )
+    test_block_record = create_test_block_record(height=uint32(10), timestamp=uint64(12345678))
+    await mempool_manager.new_peak(test_block_record, None)
+    return mempool_manager
+
+
+# adds a new peak to the memepool manager with the specified coin IDs spent
+async def advance_mempool(
+    mempool: MempoolManager, spent_coins: list[bytes32], *, use_optimization: bool = True
+) -> None:
+    br = mempool.peak
+    assert br is not None
+
+    if use_optimization:
+        next_height = uint32(br.height + 1)
+    else:
+        next_height = uint32(br.height + 2)
+
+    assert br.timestamp is not None
+    prev_block_hash = br.header_hash
+    br = create_test_block_record(height=next_height, timestamp=uint64(br.timestamp + 10))
+
+    if use_optimization:
+        assert prev_block_hash == br.prev_transaction_block_hash
+    else:
+        assert prev_block_hash != br.prev_transaction_block_hash
+
+    await mempool.new_peak(br, spent_coins)
+    invariant_check_mempool(mempool.mempool)
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("spend_singleton", [True, False])
+@pytest.mark.parametrize("spend_plain", [True, False])
+@pytest.mark.parametrize("use_optimization", [True, False])
+@pytest.mark.parametrize("reverse_spend_order", [True, False])
+async def test_new_peak_ff_eviction(
+    spend_singleton: bool, spend_plain: bool, use_optimization: bool, reverse_spend_order: bool
+) -> None:
+    LAUNCHER_ID = bytes32([1] * 32)
+    singleton_spend = make_singleton_spend(LAUNCHER_ID)
+
+    coin_spend = make_spend(
+        TEST_COIN,
+        IDENTITY_PUZZLE,
+        Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1336]]),
+    )
+    bundle = SpendBundle([singleton_spend, coin_spend], G2Element())
+
+    coins = TestCoins([singleton_spend.coin, TEST_COIN], {singleton_spend.coin.puzzle_hash: singleton_spend.coin})
+
+    mempool_manager = await setup_mempool(coins)
+
+    bundle_add_info = await mempool_manager.add_spend_bundle(
+        bundle,
+        make_test_conds(spend_ids=[(singleton_spend.coin, ELIGIBLE_FOR_FF), (TEST_COIN, 0)], cost=1000000),
+        bundle.name(),
+        first_added_height=uint32(1),
+    )
+
+    assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
+    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()].latest_singleton_coin == singleton_spend.coin.name()
+
+    spent_coins: list[bytes32] = []
+
+    if spend_singleton:
+        # pretend that we melted the singleton, the FF spend
+        coins.update_lineage(singleton_spend.coin.puzzle_hash, None)
+        coins.spend_coin(singleton_spend.coin.name(), uint32(11))
+        spent_coins.append(singleton_spend.coin.name())
+
+    if spend_plain:
+        # pretend that we spend singleton, the FF spend
+        coins.spend_coin(coin_spend.coin.name(), uint32(11))
+        spent_coins.append(coin_spend.coin.name())
+
+    assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
+    invariant_check_mempool(mempool_manager.mempool)
+
+    if reverse_spend_order:
+        spent_coins.reverse()
+
+    await advance_mempool(mempool_manager, spent_coins, use_optimization=use_optimization)
+
+    # make sure the mempool item is evicted
+    if spend_singleton or spend_plain:
+        assert mempool_manager.get_mempool_item(bundle.name()) is None
+    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()].latest_singleton_coin == singleton_spend.coin.name()
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("use_optimization", [True, False])
+async def test_multiple_ff(use_optimization: bool) -> None:
+    # create two different singleton spends of the same singleton, that support
+    # fast forward. Then update the latest singleton coin and ensure both
+    # entries in the mempool are updated accordingly
+
+    PARENT_PARENT1 = bytes32([4] * 32)
+    PARENT_PARENT2 = bytes32([5] * 32)
+    PARENT_PARENT3 = bytes32([6] * 32)
+
+    # two different spends of the same singleton. both can be fast-forwarded
+    LAUNCHER_ID = bytes32([1] * 32)
+    singleton_spend1 = make_singleton_spend(LAUNCHER_ID, PARENT_PARENT1)
+    singleton_spend2 = make_singleton_spend(LAUNCHER_ID, PARENT_PARENT2)
+
+    # in the next block, this will be the latest singleton coin
+    singleton_spend3 = make_singleton_spend(LAUNCHER_ID, PARENT_PARENT3)
+
+    coin_spend = make_spend(
+        TEST_COIN,
+        IDENTITY_PUZZLE,
+        Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1336]]),
+    )
+    bundle = SpendBundle([singleton_spend1, singleton_spend2, coin_spend], G2Element())
+
+    # the singleton puzzle hash resulves to the most recent singleton coin, number 2
+    # pretend that coin1 is spent
+    singleton_ph = singleton_spend2.coin.puzzle_hash
+    coins = TestCoins([singleton_spend1.coin, singleton_spend2.coin, TEST_COIN], {singleton_ph: singleton_spend2.coin})
+
+    mempool_manager = await setup_mempool(coins)
+
+    bundle_add_info = await mempool_manager.add_spend_bundle(
+        bundle,
+        make_test_conds(
+            spend_ids=[
+                (singleton_spend1.coin, ELIGIBLE_FOR_FF),
+                (singleton_spend2.coin, ELIGIBLE_FOR_FF),
+                (TEST_COIN, 0),
+            ],
+            cost=1000000,
+        ),
+        bundle.name(),
+        first_added_height=uint32(1),
+    )
+    assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
+    invariant_check_mempool(mempool_manager.mempool)
+
+    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
+
+    # spend the singleton coin2 and make coin3 the latest version
+    coins.update_lineage(singleton_ph, singleton_spend3.coin)
+    coins.spend_coin(singleton_spend2.coin.name(), uint32(11))
+
+    await advance_mempool(mempool_manager, [singleton_spend2.coin.name()], use_optimization=use_optimization)
+
+    # we can still fast-forward the singleton spends, the bundle should still be valid
+    item = mempool_manager.get_mempool_item(bundle.name())
+    assert item is not None
+    spend = item.bundle_coin_spends[singleton_spend1.coin.name()]
+    assert spend.latest_singleton_coin == singleton_spend3.coin.name()
+    spend = item.bundle_coin_spends[singleton_spend2.coin.name()]
+    assert spend.latest_singleton_coin == singleton_spend3.coin.name()
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("use_optimization", [True, False])
+async def test_advancing_ff(use_optimization: bool) -> None:
+    # add a FF spend under coin1, advance it twice
+    # the second time we have to search for it with a linear search, because
+    # it's filed under the original coin
+
+    PARENT_PARENT1 = bytes32([4] * 32)
+    PARENT_PARENT2 = bytes32([5] * 32)
+    PARENT_PARENT3 = bytes32([6] * 32)
+
+    # two different spends of the same singleton. both can be fast-forwarded
+    LAUNCHER_ID = bytes32([1] * 32)
+    spend_a = make_singleton_spend(LAUNCHER_ID, PARENT_PARENT1)
+    spend_b = make_singleton_spend(LAUNCHER_ID, PARENT_PARENT2)
+    spend_c = make_singleton_spend(LAUNCHER_ID, PARENT_PARENT3)
+
+    coin_spend = make_spend(
+        TEST_COIN,
+        IDENTITY_PUZZLE,
+        Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 1336]]),
+    )
+    bundle = SpendBundle([spend_a, coin_spend], G2Element())
+
+    # the singleton puzzle hash resulves to the most recent singleton coin, number 2
+    # pretend that coin1 is spent
+    singleton_ph = spend_a.coin.puzzle_hash
+    coins = TestCoins([spend_a.coin, spend_b.coin, spend_c.coin, TEST_COIN], {singleton_ph: spend_a.coin})
+
+    mempool_manager = await setup_mempool(coins)
+
+    bundle_add_info = await mempool_manager.add_spend_bundle(
+        bundle,
+        make_test_conds(spend_ids=[(spend_a.coin, ELIGIBLE_FOR_FF), (TEST_COIN, 0)], cost=1000000),
+        bundle.name(),
+        first_added_height=uint32(1),
+    )
+    assert bundle_add_info.status == MempoolInclusionStatus.SUCCESS
+    invariant_check_mempool(mempool_manager.mempool)
+
+    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.latest_singleton_coin == spend_a.coin.name()
+
+    coins.update_lineage(singleton_ph, spend_b.coin)
+    coins.spend_coin(spend_a.coin.name(), uint32(11))
+
+    await advance_mempool(mempool_manager, [spend_a.coin.name()])
+
+    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.latest_singleton_coin == spend_b.coin.name()
+
+    coins.update_lineage(singleton_ph, spend_c.coin)
+    coins.spend_coin(spend_b.coin.name(), uint32(12))
+
+    await advance_mempool(mempool_manager, [spend_b.coin.name()], use_optimization=use_optimization)
+
+    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.latest_singleton_coin == spend_c.coin.name()