chia-blockchain 2.5.1rc3__tar.gz → 2.5.2rc1__tar.gz

{chia_blockchain-2.5.1rc3 → chia_blockchain-2.5.2rc1}/PKG-INFO

@@ -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 → chia_blockchain-2.5.2rc1}/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_blockchain-2.5.1rc3 → chia_blockchain-2.5.2rc1}/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_blockchain-2.5.1rc3 → chia_blockchain-2.5.2rc1}/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_blockchain-2.5.1rc3 → chia_blockchain-2.5.2rc1}/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_blockchain-2.5.1rc3 → chia_blockchain-2.5.2rc1}/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_blockchain-2.5.1rc3 → chia_blockchain-2.5.2rc1}/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_blockchain-2.5.1rc3 → chia_blockchain-2.5.2rc1}/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_blockchain-2.5.1rc3 → chia_blockchain-2.5.2rc1}/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_blockchain-2.5.1rc3 → chia_blockchain-2.5.2rc1}/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 → chia_blockchain-2.5.2rc1}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "chia-blockchain"
 # see [tool.poetry-dynamic-versioning]
-version = "2.5.1-rc3"
+version = "2.5.2-rc1"
 description = "Chia blockchain full node, farmer, timelord, and wallet."
 authors = ["Mariano Sorgente <mariano@chia.net>"]
 license = "Apache-2.0"