chia-blockchain 2.5.1rc3__py3-none-any.whl → 2.5.2rc1__py3-none-any.whl

chia/_tests/core/mempool/test_mempool_fee_estimator.py

@@ -63,7 +63,9 @@ async def test_basics() -> None:
 async def test_fee_increase() -> None:
     async with DBConnection(db_version=2) as db_wrapper:
         coin_store = await CoinStore.create(db_wrapper)
-        mempool_manager = MempoolManager(coin_store.get_coin_records, test_constants)
+        mempool_manager = MempoolManager(
+            coin_store.get_coin_records, coin_store.get_unspent_lineage_info_for_puzzle_hash, test_constants
+        )
         assert test_constants.MAX_BLOCK_COST_CLVM == mempool_manager.constants.MAX_BLOCK_COST_CLVM
         btc_fee_estimator: BitcoinFeeEstimator = mempool_manager.mempool.fee_estimator  # type: ignore
         fee_tracker = btc_fee_estimator.get_tracker()

chia/_tests/core/mempool/test_mempool_manager.py

@@ -103,6 +103,10 @@ async def zero_calls_get_coin_records(coin_ids: Collection[bytes32]) -> list[Coi
     return []
 
 
+async def zero_calls_get_unspent_lineage_info_for_puzzle_hash(_puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
+    assert False  # pragma no cover
+
+
 async def get_coin_records_for_test_coins(coin_ids: Collection[bytes32]) -> list[CoinRecord]:
     test_coin_records = {
         TEST_COIN_ID: TEST_COIN_RECORD,
@@ -140,7 +144,12 @@ async def instantiate_mempool_manager(
     constants: ConsensusConstants = DEFAULT_CONSTANTS,
     max_tx_clvm_cost: Optional[uint64] = None,
 ) -> MempoolManager:
-    mempool_manager = MempoolManager(get_coin_records, constants, max_tx_clvm_cost=max_tx_clvm_cost)
+    mempool_manager = MempoolManager(
+        get_coin_records,
+        zero_calls_get_unspent_lineage_info_for_puzzle_hash,
+        constants,
+        max_tx_clvm_cost=max_tx_clvm_cost,
+    )
     test_block_record = create_test_block_record(height=block_height, timestamp=block_timestamp)
     await mempool_manager.new_peak(test_block_record, None)
     invariant_check_mempool(mempool_manager.mempool)
@@ -427,18 +436,18 @@ def make_bundle_spends_map_and_fee(
         eligibility_and_additions[coin_id] = EligibilityAndAdditions(
             is_eligible_for_dedup=bool(spend.flags & ELIGIBLE_FOR_DEDUP),
             spend_additions=spend_additions,
-            is_eligible_for_ff=bool(spend.flags & ELIGIBLE_FOR_FF),
+            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=[], is_eligible_for_ff=False)
+            coin_id, EligibilityAndAdditions(is_eligible_for_dedup=False, spend_additions=[], ff_puzzle_hash=None)
         )
         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.is_eligible_for_ff,
+            eligible_for_fast_forward=eligibility_info.ff_puzzle_hash is not None,
             additions=eligibility_info.spend_additions,
         )
     fee = uint64(removals_amount - additions_amount)
@@ -1137,7 +1146,7 @@ async def test_create_bundle_from_mempool_on_max_cost(num_skipped_items: int, ca
     skipped_due_to_eligible_coins = sum(
         1
         for line in caplog.text.split("\n")
-        if "DEBUG Exception while checking a mempool item for deduplication: Skipping transaction with eligible coin(s)"
+        if "Exception while checking a mempool item for deduplication: Skipping transaction with eligible coin(s)"
         in line
     )
     if num_skipped_items == PRIORITY_TX_THRESHOLD:

chia/_tests/core/mempool/test_singleton_fast_forward.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+import copy
 import dataclasses
 from typing import Any, Optional
 
 import pytest
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chiabip158 import PyBIP158
 
 from chia._tests.clvm.test_puzzles import public_key_for_index, secret_exponent_for_index
 from chia._tests.core.mempool.test_mempool_manager import (
@@ -57,14 +59,14 @@ async def test_process_fast_forward_spends_nothing_to_do() -> None:
     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()
-    await eligible_coin_spends.process_fast_forward_spends(
+    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,
     )
     assert eligible_coin_spends == EligibleCoinSpends()
-    assert internal_mempool_item == original_version
+    assert bundle_coin_spends == original_version.bundle_coin_spends
 
 
 @pytest.mark.anyio
@@ -130,7 +132,7 @@ async def test_process_fast_forward_spends_latest_unspent() -> None:
     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()
-    await eligible_coin_spends.process_fast_forward_spends(
+    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,
@@ -149,7 +151,7 @@ async def test_process_fast_forward_spends_latest_unspent() -> None:
     # We have set the next version from our additions to chain ff spends
     assert eligible_coin_spends.fast_forward_spends == expected_fast_forward_spends
     # We didn't need to fast forward the item so it stays as is
-    assert internal_mempool_item == original_version
+    assert bundle_coin_spends == original_version.bundle_coin_spends
 
 
 def test_perform_the_fast_forward() -> None:
@@ -381,6 +383,47 @@ async def prepare_and_test_singleton(
     return singleton, eve_coin_spend, inner_puzzle, remaining_coin
 
 
+@pytest.mark.anyio
+async def test_singleton_fast_forward_solo() -> None:
+    """
+    We don't allow a spend bundle with *only* fast forward spends, since those
+    are difficult to evict from the mempool. They would always be valid as long as
+    the singleton exists.
+    """
+    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
+        )
+        singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
+        inner_puzzle_hash = inner_puzzle.get_tree_hash()
+        inner_conditions: list[list[Any]] = [
+            [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_AMOUNT],
+        ]
+        singleton_coin_spend, _ = make_singleton_coin_spend(eve_coin_spend, singleton, inner_puzzle, inner_conditions)
+        # spending the eve coin is not eligible for fast forward, so we need to make this spend first, to test FF
+        await make_and_send_spend_bundle(sim, sim_client, [singleton_coin_spend], aggsig=G2Element())
+        unspent_lineage_info = await sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash(
+            singleton_puzzle_hash
+        )
+        singleton_child, _ = 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=eve_coin_spend.coin.name(),
+            parent_amount=singleton.amount,
+            parent_parent_id=eve_coin_spend.coin.parent_coin_info,
+        )
+
+        inner_conditions = [[ConditionOpcode.CREATE_COIN, inner_puzzle_hash, 21]]
+        # this is a FF spend that isn't combined with any other spend. It's not allowed
+        singleton_coin_spend, _ = make_singleton_coin_spend(eve_coin_spend, singleton, inner_puzzle, inner_conditions)
+        status, error = await sim_client.push_tx(SpendBundle([singleton_coin_spend], G2Element()))
+        assert error is Err.INVALID_SPEND_BUNDLE
+        assert status == MempoolInclusionStatus.FAILED
+
+
 @pytest.mark.anyio
 @pytest.mark.parametrize("is_eligible_for_ff", [True, False])
 async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool) -> None:
@@ -544,7 +587,8 @@ async def test_singleton_fast_forward_same_block() -> None:
             singleton_coin_spend, _ = make_singleton_coin_spend(
                 eve_coin_spend, singleton, inner_puzzle, inner_conditions
             )
-            status, error = await sim_client.push_tx(SpendBundle([singleton_coin_spend], aggsig))
+            remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
+            status, error = await sim_client.push_tx(SpendBundle([singleton_coin_spend, remaining_coin_spend], aggsig))
             assert error is None
             assert status == MempoolInclusionStatus.SUCCESS
 
@@ -565,3 +609,135 @@ async def test_singleton_fast_forward_same_block() -> None:
         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 == random_amounts[-2]
+
+
+@pytest.mark.anyio
+async def test_mempool_items_immutability_on_ff() -> None:
+    """
+    This tests processing singleton fast forward spends for mempool items using
+    modified copies, without altering those original mempool items.
+    """
+    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
+        )
+        singleton_name = singleton.name()
+        singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
+        inner_puzzle_hash = inner_puzzle.get_tree_hash()
+        sk = AugSchemeMPL.key_gen(b"1" * 32)
+        g1 = sk.get_g1()
+        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, SINGLETON_AMOUNT],
+        ]
+        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_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],
+            signing_puzzle=singleton_signing_puzzle,
+            signing_coin=singleton,
+            aggsig=sig,
+        )
+        unspent_lineage_info = await sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash(
+            singleton_puzzle_hash
+        )
+        singleton_child, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
+        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(),
+        )
+        # 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_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
+        sb = SpendBundle([remaining_coin_spend, singleton_coin_spend], sig)
+        sb_name = sb.name()
+        status, error = await sim_client.push_tx(sb)
+        assert status == MempoolInclusionStatus.SUCCESS
+        assert error is 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,
+            sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash,
+        )
+        assert result is not None
+        bundle, _ = result
+        # Make sure the mempool bundle we created contains the result of our
+        # fast forward, instead of our original spend.
+        assert any(cs.coin.name() == singleton_child_name for cs in bundle.coin_spends)
+        assert not any(cs.coin.name() == singleton_name for cs in bundle.coin_spends)
+        # We should have processed our item without modifying it in-place
+        new_item = copy.copy(sim_client.service.mempool_manager.get_mempool_item(sb_name))
+        new_filter = sim_client.service.mempool_manager.get_filter()
+        assert new_item == original_item
+        assert new_filter == original_filter
+        sb_filter = PyBIP158(bytearray(original_filter))
+        items_not_in_sb_filter = sim_client.service.mempool_manager.get_items_not_in_filter(sb_filter)
+        assert len(items_not_in_sb_filter) == 0
+
+
+@pytest.mark.anyio
+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)
+    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
+        )
+        singleton_name = singleton.name()
+        singleton_puzzle_hash = eve_coin_spend.coin.puzzle_hash
+        inner_puzzle_hash = inner_puzzle.get_tree_hash()
+        sk = AugSchemeMPL.key_gen(b"9" * 32)
+        g1 = sk.get_g1()
+        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],
+        ]
+        singleton_coin_spend, _ = make_singleton_coin_spend(eve_coin_spend, singleton, inner_puzzle, inner_conditions)
+        # Get its current latest unspent info
+        unspent_lineage_info = await sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash(
+            singleton_puzzle_hash
+        )
+        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
+        async with sim_client.service.coin_store.db_wrapper.writer_maybe_transaction() as conn:
+            await conn.execute("DELETE FROM coin_record WHERE coin_name = ?", (unspent_lineage_info.coin_id,))
+        # This singleton no longer has a latest unspent coin
+        unspent_lineage_info = await sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash(
+            singleton_puzzle_hash
+        )
+        assert unspent_lineage_info is None
+        # Let's attempt to spend this singleton and get get it fast forwarded
+        status, error = await make_and_send_spend_bundle(sim, sim_client, [singleton_coin_spend], aggsig=sig)
+        # It fails validation because it doesn't currently have a latest unspent
+        assert status == MempoolInclusionStatus.FAILED
+        assert error == Err.DOUBLE_SPEND

chia/_tests/util/spend_sim.py

@@ -165,7 +165,9 @@ class SpendSim:
         async with DBWrapper2.managed(database=uri, uri=True, reader_count=1, db_version=2) as self.db_wrapper:
             self.coin_store = await CoinStore.create(self.db_wrapper)
             self.hint_store = await HintStore.create(self.db_wrapper)
-            self.mempool_manager = MempoolManager(self.coin_store.get_coin_records, defaults)
+            self.mempool_manager = MempoolManager(
+                self.coin_store.get_coin_records, self.coin_store.get_unspent_lineage_info_for_puzzle_hash, defaults
+            )
             self.defaults = defaults
 
             # Load the next data if there is any

chia/full_node/full_node.py

@@ -274,6 +274,7 @@ class FullNode:
 
             self._mempool_manager = MempoolManager(
                 get_coin_records=self.coin_store.get_coin_records,
+                get_unspent_lineage_info_for_puzzle_hash=self.coin_store.get_unspent_lineage_info_for_puzzle_hash,
                 consensus_constants=self.constants,
                 single_threaded=single_threaded,
             )

chia/full_node/mempool.py

@@ -526,14 +526,14 @@ class Mempool:
                         unique_additions.extend(spend_data.additions)
                     cost_saving = 0
                 else:
-                    await eligible_coin_spends.process_fast_forward_spends(
+                    bundle_coin_spends = await eligible_coin_spends.process_fast_forward_spends(
                         mempool_item=item,
                         get_unspent_lineage_info_for_puzzle_hash=get_unspent_lineage_info_for_puzzle_hash,
                         height=height,
                         constants=constants,
                     )
                     unique_coin_spends, cost_saving, unique_additions = eligible_coin_spends.get_deduplication_info(
-                        bundle_coin_spends=item.bundle_coin_spends, max_cost=cost
+                        bundle_coin_spends=bundle_coin_spends, max_cost=cost
                     )
                 item_cost = cost - cost_saving
                 log.info(
@@ -570,7 +570,7 @@ class Mempool:
                 if self.mempool_info.max_block_clvm_cost - cost_sum < MIN_COST_THRESHOLD:
                     break
             except Exception as e:
-                log.debug(f"Exception while checking a mempool item for deduplication: {e}")
+                log.info(f"Exception while checking a mempool item for deduplication: {e}")
                 continue
         if processed_spend_bundles == 0:
             return None

chia/full_node/mempool_manager.py

@@ -129,6 +129,7 @@ class MempoolManager:
     constants: ConsensusConstants
     seen_bundle_hashes: dict[bytes32, bytes32]
     get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]]
+    get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]]
     nonzero_fee_minimum_fpc: int
     mempool_max_total_cost: int
     # a cache of MempoolItems that conflict with existing items in the pool
@@ -145,6 +146,7 @@ class MempoolManager:
     def __init__(
         self,
         get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
+        get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
         consensus_constants: ConsensusConstants,
         *,
         single_threaded: bool = False,
@@ -156,6 +158,7 @@ class MempoolManager:
         self.seen_bundle_hashes: dict[bytes32, bytes32] = {}
 
         self.get_coin_records = get_coin_records
+        self.get_unspent_lineage_info_for_puzzle_hash = get_unspent_lineage_info_for_puzzle_hash
 
         # The fee per cost must be above this amount to consider the fee "nonzero", and thus able to kick out other
         # transactions. This prevents spam. This is equivalent to 0.055 XCH per block, or about 0.00005 XCH for two
@@ -349,6 +352,7 @@ class MempoolManager:
             spend_name,
             first_added_height,
             get_coin_records,
+            self.get_unspent_lineage_info_for_puzzle_hash,
         )
         if err is None:
             # No error, immediately add to mempool, after removing conflicting TXs.
@@ -379,6 +383,7 @@ class MempoolManager:
         spend_name: bytes32,
         first_added_height: uint32,
         get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
+        get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
     ) -> tuple[Optional[Err], Optional[MempoolItem], list[bytes32]]:
         """
         Validates new_spend with the given NPCResult, and spend_name, and the current mempool. The mempool should
@@ -423,7 +428,7 @@ class MempoolManager:
             eligibility_and_additions[coin_id] = EligibilityAndAdditions(
                 is_eligible_for_dedup=is_eligible_for_dedup,
                 spend_additions=spend_additions,
-                is_eligible_for_ff=is_eligible_for_ff,
+                ff_puzzle_hash=bytes32(spend.puzzle_hash) if is_eligible_for_ff else None,
             )
         removal_names_from_coin_spends: set[bytes32] = set()
         fast_forward_coin_ids: set[bytes32] = set()
@@ -433,14 +438,20 @@ class MempoolManager:
             removal_names_from_coin_spends.add(coin_id)
             eligibility_info = eligibility_and_additions.get(
                 coin_id,
-                EligibilityAndAdditions(is_eligible_for_dedup=False, spend_additions=[], is_eligible_for_ff=False),
+                EligibilityAndAdditions(is_eligible_for_dedup=False, spend_additions=[], ff_puzzle_hash=None),
             )
-            mark_as_fast_forward = eligibility_info.is_eligible_for_ff and supports_fast_forward(coin_spend)
+            mark_as_fast_forward = eligibility_info.ff_puzzle_hash is not None and supports_fast_forward(coin_spend)
+            if mark_as_fast_forward:
+                # Make sure the fast forward spend still has a version that is
+                # still unspent, because if the singleton has been melted, the
+                # fast forward spend will never become valid.
+                assert eligibility_info.ff_puzzle_hash is not None
+                if await get_unspent_lineage_info_for_puzzle_hash(eligibility_info.ff_puzzle_hash) is None:
+                    return Err.DOUBLE_SPEND, None, []
+                fast_forward_coin_ids.add(coin_id)
             # We are now able to check eligibility of both dedup and fast forward
             if not (eligibility_info.is_eligible_for_dedup or mark_as_fast_forward):
                 non_eligible_coin_ids.append(coin_id)
-            if mark_as_fast_forward:
-                fast_forward_coin_ids.add(coin_id)
             bundle_coin_spends[coin_id] = BundleCoinSpend(
                 coin_spend=coin_spend,
                 eligible_for_dedup=eligibility_info.is_eligible_for_dedup,
@@ -452,6 +463,12 @@ class MempoolManager:
             # If you reach here it's probably because your program reveal doesn't match the coin's puzzle hash
             return Err.INVALID_SPEND_BUNDLE, None, []
 
+        # fast forward spends are only allowed when bundled with other, non-FF, spends
+        # in order to evict an FF spend, it must be associated with a normal
+        # spend that can be included in a block or invalidated some other way
+        if all([s.eligible_for_fast_forward for s in bundle_coin_spends.values()]):
+            return Err.INVALID_SPEND_BUNDLE, None, []
+
         removal_record_dict: dict[bytes32, CoinRecord] = {}
         removal_amount: int = 0
         removal_records = await get_coin_records(removal_names)

chia/types/eligible_coin_spends.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 import dataclasses
 from collections.abc import Awaitable
 from typing import Callable, Optional
@@ -23,7 +24,10 @@ from chia.util.ints import uint32, uint64
 class EligibilityAndAdditions:
     is_eligible_for_dedup: bool
     spend_additions: list[Coin]
-    is_eligible_for_ff: bool
+    # This is the spend puzzle hash. It's set to `None` if the spend is not
+    # eligible for fast forward. When the spend is eligible, we use its puzzle
+    # hash to check if the singleton has an unspent coin or not.
+    ff_puzzle_hash: Optional[bytes32] = None
 
 
 def run_for_cost(
@@ -233,26 +237,36 @@ class EligibleCoinSpends:
         get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
         height: uint32,
         constants: ConsensusConstants,
-    ) -> None:
+    ) -> dict[bytes32, BundleCoinSpend]:
         """
-        Provides the caller with an in-place internal mempool item that has a
-        proper state of fast forwarded coin spends and additions starting from
+        Provides the caller with a `bundle_coin_spends` map that has a proper
+        state of fast forwarded coin spends and additions starting from
         the most recent unspent versions of the related singleton spends.
 
         Args:
-            mempool_item: in-out parameter for the internal mempool item to process
+            mempool_item: The internal mempool item to process
             get_unspent_lineage_info_for_puzzle_hash: to lookup the most recent
                 version of the singleton from the coin store
             constants: needed in order to refresh the mempool item if needed
             height: needed in order to refresh the mempool item if needed
 
+        Returns:
+            The resulting `bundle_coin_spends` map of coin IDs to coin spends
+            and metadata, after fast forwarding
+
         Raises:
             If a fast forward cannot proceed, to prevent potential double spends
         """
+
+        # Let's first create a copy of the mempool item's `bundle_coin_spends`
+        # map to work on and return. This way we avoid the possibility of
+        # propagating a modified version of this item through the network.
+        bundle_coin_spends = copy.copy(mempool_item.bundle_coin_spends)
         new_coin_spends = []
+        # Map of rebased singleton coin ID to coin spend and metadata
         ff_bundle_coin_spends = {}
         replaced_coin_ids = []
-        for coin_id, spend_data in mempool_item.bundle_coin_spends.items():
+        for coin_id, spend_data in bundle_coin_spends.items():
             if not spend_data.eligible_for_fast_forward:
                 # Nothing to do for this spend, moving on
                 new_coin_spends.append(spend_data.coin_spend)
@@ -326,21 +340,17 @@ class EligibleCoinSpends:
             new_coin_spends.append(new_coin_spend)
         if len(ff_bundle_coin_spends) == 0:
             # This item doesn't have any fast forward coins, nothing to do here
-            return
+            return bundle_coin_spends
         # Update the mempool item after validating the new spend bundle
         new_sb = SpendBundle(
             coin_spends=new_coin_spends, aggregated_signature=mempool_item.spend_bundle.aggregated_signature
         )
-        # We need to run the new spend bundle to make sure it remains valid
         assert mempool_item.conds is not None
         try:
-            new_conditions = get_conditions_from_spendbundle(
-                new_sb,
-                mempool_item.conds.cost,
-                constants,
-                height,
-            )
-        # validate_clvm_and_signature raises a TypeError with an error code
+            # Run the new spend bundle to make sure it remains valid. What we
+            # care about here is whether this call throws or not.
+            get_conditions_from_spendbundle(new_sb, mempool_item.conds.cost, constants, height)
+        # get_conditions_from_spendbundle raises a TypeError with an error code
         except TypeError as e:
             # Convert that to a ValidationError
             if len(e.args) > 0:
@@ -351,15 +361,9 @@ class EligibleCoinSpends:
                     "Mempool item became invalid after singleton fast forward with an unspecified error."
                 )  # pragma: no cover
 
-        # Update bundle_coin_spends using the collected data
+        # Update bundle_coin_spends using the map of rebased singleton coin ID
+        # to coin spend and metadata.
         for coin_id in replaced_coin_ids:
-            mempool_item.bundle_coin_spends.pop(coin_id, None)
-        mempool_item.bundle_coin_spends.update(ff_bundle_coin_spends)
-        # Update the mempool item with the new spend bundle related information
-        # NOTE: From this point on, in `create_bundle_from_mempool_items`, we rely
-        # on `bundle_coin_spends` and we don't use this updated spend bundle
-        # information, as we'll only need `aggregated_signature` which doesn't
-        # change. Still, it's good form to update the spend bundle with the
-        # new coin spends
-        mempool_item.spend_bundle = new_sb
-        mempool_item.conds = new_conditions
+            bundle_coin_spends.pop(coin_id, None)
+        bundle_coin_spends.update(ff_bundle_coin_spends)
+        return bundle_coin_spends

chia/types/internal_mempool_item.py

@@ -9,7 +9,7 @@ from chia.types.spend_bundle_conditions import SpendBundleConditions
 from chia.util.ints import uint32
 
 
-@dataclass
+@dataclass(frozen=True)
 class InternalMempoolItem:
     spend_bundle: SpendBundle
     conds: SpendBundleConditions

{chia_blockchain-2.5.1rc3.dist-info → chia_blockchain-2.5.2rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: chia-blockchain
-Version: 2.5.1rc3
+Version: 2.5.2rc1
 Summary: Chia blockchain full node, farmer, timelord, and wallet.
 License: Apache-2.0
 Keywords: chia,blockchain,node

{chia_blockchain-2.5.1rc3.dist-info → chia_blockchain-2.5.2rc1.dist-info}/RECORD

@@ -121,12 +121,12 @@ chia/_tests/core/make_block_generator.py,sha256=m9Uq39ZMuAkwSV5cPQt5jE8ysaSEJwqG
 chia/_tests/core/mempool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/_tests/core/mempool/config.py,sha256=-GncDnWBQwvk5MHfOhjQ4DnUD3VlxrD8lLrt8Gd2D5c,86
 chia/_tests/core/mempool/test_mempool.py,sha256=HlrEIAk70dGvNodQm_pHmSDYez6rF2fgS_BVK3Ezzd4,141045
-chia/_tests/core/mempool/test_mempool_fee_estimator.py,sha256=K6yjcyR4I6CHGbx8DhKrwDaOLcJj3hFRinhPO1NDnPA,3635
+chia/_tests/core/mempool/test_mempool_fee_estimator.py,sha256=SSzCp4Tw4LMp2yYzEjzyf6UHejWKm_dDpMkpyas6MZs,3710
 chia/_tests/core/mempool/test_mempool_fee_protocol.py,sha256=iD8R9S8falpF4WRxBeNSF8fpeoAY3e8K5FT4DYWSDDw,2161
 chia/_tests/core/mempool/test_mempool_item_queries.py,sha256=BESoQXx8XG2jSJiE12nslC3y_vPWrfCWPCrv4tGl3Js,7027
-chia/_tests/core/mempool/test_mempool_manager.py,sha256=uuRWhZcsqkPfEKSKclsZFz6YKWiGVGPBBMSU6AhGJdA,96802
+chia/_tests/core/mempool/test_mempool_manager.py,sha256=zRxgq74FRmxDm8KbhunW40f3aWZzVEQp3-qtgIw1S00,97083
 chia/_tests/core/mempool/test_mempool_performance.py,sha256=EJ5cZkSOoQDSmt68GMAiYdmFWNOtJq0AnROJManU184,2800
-chia/_tests/core/mempool/test_singleton_fast_forward.py,sha256=JH6a_Oraaml1V3q5hLClt0xT7Bsx9IB-AEr4lXJu9zg,29166
+chia/_tests/core/mempool/test_singleton_fast_forward.py,sha256=qySBET8zAXbQwx3xxedj0wUEIv73hwHE93OliHZ3W1g,38572
 chia/_tests/core/node_height.py,sha256=MHC8fEZXvDCU-7zCWXwnSaWx-iECEvyl51OpitIMQIE,912
 chia/_tests/core/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/_tests/core/server/config.py,sha256=fTDhByaME5cEDbtyTKCWUf69F4kajs75aTQewZMjxak,69
@@ -277,7 +277,7 @@ chia/_tests/util/protocol_messages_json.py,sha256=7c8bq0PSnyyX80guTe3VB_tAqkeAv1
 chia/_tests/util/rpc.py,sha256=g-vf7Nnp9Myr588lR2uyRs12eeQ1FIJ73h4FTFqiUeo,825
 chia/_tests/util/run_block.py,sha256=qkjF45klRj0KXkHf9z6k2aY8SUJmUT8cJVg_NoTjE9Y,6006
 chia/_tests/util/setup_nodes.py,sha256=DKKa_aZVXEfg7sd7dqWE2DDrGLvI6dB7SCslJbN2QA8,18407
-chia/_tests/util/spend_sim.py,sha256=19Z89jzmhxszLW_yYyzc_hSxmaZ1zitcxXnp1G5qxd8,20976
+chia/_tests/util/spend_sim.py,sha256=OTlZslTN24PQ2Q3bGWKvG7JoXQ3RhhWkGzbqq59N29k,21064
 chia/_tests/util/split_managers.py,sha256=n7y0gvtkpOyGvMNAd1iYzeSrwXhlwcKcaRZfBE1FMPw,3069
 chia/_tests/util/temp_file.py,sha256=tQnufsTZahaxYBQrRvArmwB0ZF3Q4-8ZxauQJ4-dKr4,306
 chia/_tests/util/test_action_scope.py,sha256=0xJyAPL4NmJpWWJ6_QA6v-RpAh4RQeFRH1DrJGk9Biw,5220
@@ -524,14 +524,14 @@ chia/full_node/fee_estimator_constants.py,sha256=GsQfI9Z7YzPWGEe6ghJeYvzbG87C86K
 chia/full_node/fee_estimator_interface.py,sha256=GoeD5RVmIsb4_qW-9AGttglwcDIpdIxFrEhqLUXp-Mw,1606
 chia/full_node/fee_history.py,sha256=MniggGft1CVGHOJR7HI9YqGBP4er2dwL7Xzmm2E9JxU,586
 chia/full_node/fee_tracker.py,sha256=HH8ZVxU9Md6oHobP1O2_q1bBu-o75nicQ2BeETGQxi0,22621
-chia/full_node/full_node.py,sha256=BfiOfLEqY1wZlmgdKWywAb1UtPppuRpwKkvG1RdplXg,165907
+chia/full_node/full_node.py,sha256=l2Xgx0kTSzhOvynY6ZNHA9Izp1HsPk4M8Sm-0qWJ3NQ,166022
 chia/full_node/full_node_api.py,sha256=JEkwf5mc9W1kokbR-P3vJntSU83Kf5R3nUic_XAICPw,98371
 chia/full_node/full_node_store.py,sha256=1NIj4TWwFjrVHtnAl3F5i1dFPEW2QA5pwTNM4xN3Vbs,47402
 chia/full_node/hint_management.py,sha256=P-NbUWOEoRyIp-_rUkIUm2lP7KrN9N5on57QIQio9mU,2305
 chia/full_node/hint_store.py,sha256=Lr8oR1ptmEJE3H7VghEJrhHXtX8YIXr3cNTnsJZLgk0,3687
-chia/full_node/mempool.py,sha256=G_C-4ikcSdrsavbpvVymWtvghhZkZAw8qvsBE2rPr3U,25080
+chia/full_node/mempool.py,sha256=kk6r-zCCZelnyx7DoJl0FydUSynudbB6DQToSYy4Ozo,25095
 chia/full_node/mempool_check_conditions.py,sha256=AeTVTkrg4mK2kbdYOgmr1QcBDXUF3B3X-SSoshwgvgY,5751
-chia/full_node/mempool_manager.py,sha256=7_2Rj3OuwCuYrmKIR3BmfZuoHhB_Z4WqGoH5moRTpgI,38477
+chia/full_node/mempool_manager.py,sha256=kwz8hPqniRiBVzQexfGVdEIv-VTvuhffkfZD9DOWk5Y,39833
 chia/full_node/pending_tx_cache.py,sha256=wKy-7KSOMIPAb7Y1nQcK7HHIFCNaFeMiIxBEP5U4T6Q,3674
 chia/full_node/puzzles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/full_node/puzzles/block_program_zero.clsp,sha256=VeDPXnkPB2_1xH94Kzx4ntgk20fRI7AiWHCWaB95aJc,642
@@ -705,13 +705,13 @@ chia/types/coin_record.py,sha256=BEutj_kc5DzzRxlhv37TWhsjLMwwQ63z5cQIVmVSnoI,128
 chia/types/coin_spend.py,sha256=Q_U4DqHJo6kvx36ON__c3LZ_9NC1qK-jZFjuHE51ozI,4130
 chia/types/condition_opcodes.py,sha256=nFibKuhiR0FwXUB0hqDQbv0Ngfb-BezNKTfDzoa3vII,2213
 chia/types/condition_with_args.py,sha256=N5f6V0ok1cLSTG-4YqAGOISYyhixC8745LGYqvu0Y58,389
-chia/types/eligible_coin_spends.py,sha256=7G6A9V047j_1ej3oLa_-XXtChr08_ZMkLW5XDNhKmmk,17772
+chia/types/eligible_coin_spends.py,sha256=jyBVuuj64eKwUN6u9fRHchgMwkawZCNMV2pVnVF9UTI,18071
 chia/types/end_of_slot_bundle.py,sha256=l6Oqhk4cnZgfmAKAToSMwsUnK2m9wpw5AJauwn-19WY,100
 chia/types/fee_rate.py,sha256=rtCF9o5sI-6fVzRjRsBl0b3mYHB7Ik1p9IkQtbrGQAw,854
 chia/types/full_block.py,sha256=2WqaqUwiJImjKJTE59C3zZdYPFdN5ZNfpn8AQiCVAGw,82
 chia/types/generator_types.py,sha256=U2qtssNjKRnfSoidf-ziiB0r4iFzkV0-MYy-Bj2N-n0,340
 chia/types/header_block.py,sha256=sTLOSI-Jpg1dwOJfKjHVFvauWK95AdpHReKmaes_cMs,86
-chia/types/internal_mempool_item.py,sha256=Z2iwQ0Ro9dLpurSO2omAW3029lPWwhOhDOa-2LDxfYg,606
+chia/types/internal_mempool_item.py,sha256=3UxMtcHm6mbg_54aT3GBtWS39arhu7NfINjlLKHCfck,619
 chia/types/mempool_inclusion_status.py,sha256=iduTqYGvOMyVkDfiHmqESjHvbzP_6ZsawTIkKV8DXQc,260
 chia/types/mempool_item.py,sha256=v9KJLaN_4_N02xY2eDIMj_knBJ-WNJGSvRtGKlwgxDk,2820
 chia/types/mempool_submission_status.py,sha256=Q8aaZ7UQp0FyJt9CnAto63s-_RJOVoN2OpZ5h4fB01g,1049
@@ -1035,8 +1035,8 @@ chia/wallet/wallet_transaction_store.py,sha256=thFNbDkOEXbwYyToZB5uafnaj4VqDteHq
 chia/wallet/wallet_user_store.py,sha256=lVJyOKPO6zB66EIHZA7rG9u-5V_MC0AtiEuDubU8RBk,4084
 chia/wallet/wallet_weight_proof_handler.py,sha256=LKfnVR2HM1-7vdkSwoIVFUc7QIUvnhQPscZZCSKFvl0,4926
 mozilla-ca/cacert.pem,sha256=o_Mowh453dHyvhzqQ6wN7IGeqiCpBCXX2pAaEVMbOqU,231212
-chia_blockchain-2.5.1rc3.dist-info/LICENSE,sha256=0tuU-jTzeRDJJaxF2YCEpBwbywgpbrVSXq1i6fJq63U,11347
-chia_blockchain-2.5.1rc3.dist-info/METADATA,sha256=QZGVsVnPjyzqo9KwqVuKNM1wpIzoRUSKSqlRQ6-NsHs,10631
-chia_blockchain-2.5.1rc3.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-chia_blockchain-2.5.1rc3.dist-info/entry_points.txt,sha256=GL2-UvicPVdKz72IP4shnmV3XImfoD5pMzoURfoAYk4,742
-chia_blockchain-2.5.1rc3.dist-info/RECORD,,
+chia_blockchain-2.5.2rc1.dist-info/LICENSE,sha256=0tuU-jTzeRDJJaxF2YCEpBwbywgpbrVSXq1i6fJq63U,11347
+chia_blockchain-2.5.2rc1.dist-info/METADATA,sha256=anievx9tDspq_YHuwSU-xpQbiolfbLZSdkIVQAdczrw,10631
+chia_blockchain-2.5.2rc1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+chia_blockchain-2.5.2rc1.dist-info/entry_points.txt,sha256=GL2-UvicPVdKz72IP4shnmV3XImfoD5pMzoURfoAYk4,742
+chia_blockchain-2.5.2rc1.dist-info/RECORD,,

{chia_blockchain-2.5.1rc3.dist-info → chia_blockchain-2.5.2rc1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: poetry-core 2.1.1
 Root-Is-Purelib: true
 Tag: py3-none-any