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

chia/full_node/mempool.py

@@ -9,23 +9,24 @@ from enum import Enum
 from time import monotonic
 from typing import Callable, Optional
 
-from chia_rs import AugSchemeMPL, Coin, G2Element
+from chia_rs import AugSchemeMPL, Coin, ConsensusConstants, G2Element, solution_generator_backrefs
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 
-from chia.consensus.constants import ConsensusConstants
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.fee_estimation import FeeMempoolInfo, MempoolInfo, MempoolItemInfo
 from chia.full_node.fee_estimator_interface import FeeEstimatorInterface
-from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.clvm_cost import CLVMCost
 from chia.types.coin_spend import CoinSpend
-from chia.types.eligible_coin_spends import EligibleCoinSpends, UnspentLineageInfo
+from chia.types.eligible_coin_spends import EligibleCoinSpends, SkipDedup, UnspentLineageInfo
+from chia.types.generator_types import BlockGenerator
 from chia.types.internal_mempool_item import InternalMempoolItem
 from chia.types.mempool_item import MempoolItem
 from chia.types.spend_bundle import SpendBundle
 from chia.util.batches import to_batches
 from chia.util.db_wrapper import SQLITE_MAX_VARIABLE_NUMBER
 from chia.util.errors import Err
-from chia.util.ints import uint32, uint64
 
 log = logging.getLogger(__name__)
 
@@ -451,10 +452,20 @@ class Mempool:
                     item.fee / item.cost,
                 ),
             )
-            all_coin_spends = [(s.coin_id, item.name) for s in item.conds.spends]
-            conn.executemany("INSERT INTO spends VALUES(?, ?)", all_coin_spends)
+            all_coin_spends = []
+            # item.name is a property
+            # only compute its name once (the spend bundle name)
+            item_name = item.name
+            for coin_id, bcs in item.bundle_coin_spends.items():
+                # any FF spend should be indexed by its latest singleton coin
+                # ID, this way we'll find it when the singleton is spent
+                if bcs.latest_singleton_coin is not None:
+                    all_coin_spends.append((bcs.latest_singleton_coin, item_name))
+                else:
+                    all_coin_spends.append((coin_id, item_name))
+            conn.executemany("INSERT OR IGNORE INTO spends VALUES(?, ?)", all_coin_spends)
 
-        self._items[item.name] = InternalMempoolItem(
+        self._items[item_name] = InternalMempoolItem(
             item.spend_bundle, item.conds, item.height_added_to_mempool, item.bundle_coin_spends
         )
         self._total_cost += item.cost
@@ -464,6 +475,11 @@ class Mempool:
         self.fee_estimator.add_mempool_item(info, MempoolItemInfo(item.cost, item.fee, item.height_added_to_mempool))
         return MempoolAddInfo(removals, None)
 
+    # each tuple holds new_coin_id, current_coin_id, mempool item name
+    def update_spend_index(self, spends_to_update: list[tuple[bytes32, bytes32, bytes32]]) -> None:
+        with self._db_conn as conn:
+            conn.executemany("UPDATE OR REPLACE spends SET coin_id=? WHERE coin_id=? AND tx=?", spends_to_update)
+
     def at_full_capacity(self, cost: int) -> bool:
         """
         Checks whether the mempool is at full capacity and cannot accept a transaction with size cost.
@@ -471,12 +487,53 @@ class Mempool:
 
         return self._total_cost + cost > self.mempool_info.max_size_in_cost
 
+    async def create_block_generator(
+        self,
+        get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
+        constants: ConsensusConstants,
+        height: uint32,
+        item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
+    ) -> Optional[tuple[BlockGenerator, G2Element, list[Coin], list[Coin]]]:
+        """
+        height is needed in case we fast-forward a transaction and we need to
+        re-run its puzzle.
+        """
+
+        mempool_bundle = await self.create_bundle_from_mempool_items(
+            get_unspent_lineage_info_for_puzzle_hash, constants, height, item_inclusion_filter
+        )
+        if mempool_bundle is None:
+            return None
+
+        spend_bundle, additions = mempool_bundle
+        removals = spend_bundle.removals()
+        log.info(f"Add rem: {len(additions)} {len(removals)}")
+
+        # since the hard fork has activated, block generators are
+        # allowed to be serialized with CLVM back-references. We can do that
+        # unconditionally.
+        start_time = monotonic()
+        spends = [(cs.coin, bytes(cs.puzzle_reveal), bytes(cs.solution)) for cs in spend_bundle.coin_spends]
+        block_program = solution_generator_backrefs(spends)
+
+        duration = monotonic() - start_time
+        log.log(
+            logging.INFO if duration < 1 else logging.WARNING,
+            f"serializing block generator took {duration:0.2f} seconds",
+        )
+        return (
+            BlockGenerator(SerializedProgram.from_bytes(block_program), []),
+            spend_bundle.aggregated_signature,
+            additions,
+            removals,
+        )
+
     async def create_bundle_from_mempool_items(
         self,
-        item_inclusion_filter: Callable[[bytes32], bool],
         get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
         constants: ConsensusConstants,
         height: uint32,
+        item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
     ) -> Optional[tuple[SpendBundle, list[Coin]]]:
         cost_sum = 0  # Checks that total cost does not exceed block maximum
         fee_sum = 0  # Checks that total fees don't exceed 64 bits
@@ -506,7 +563,7 @@ class Mempool:
             if current_time - bundle_creation_start > 1:
                 log.info(f"exiting early, already spent {current_time - bundle_creation_start:0.2f} s")
                 break
-            if not item_inclusion_filter(name):
+            if item_inclusion_filter is not None and not item_inclusion_filter(name):
                 continue
             try:
                 assert item.conds is not None
@@ -517,11 +574,18 @@ class Mempool:
                     # we want to keep looking for smaller transactions that
                     # might fit, but we also want to avoid spending too much
                     # time on potentially expensive ones, hence this shortcut.
+                    if any(
+                        map(
+                            lambda spend_data: (spend_data.eligible_for_dedup or spend_data.eligible_for_fast_forward),
+                            item.bundle_coin_spends.values(),
+                        )
+                    ):
+                        log.info("Skipping transaction with dedup or FF spends {item.name}")
+                        continue
+
                     unique_coin_spends = []
                     unique_additions = []
                     for spend_data in item.bundle_coin_spends.values():
-                        if spend_data.eligible_for_dedup or spend_data.eligible_for_fast_forward:
-                            raise Exception(f"Skipping transaction with eligible coin(s): {name.hex()}")
                         unique_coin_spends.append(spend_data.coin_spend)
                         unique_additions.extend(spend_data.additions)
                     cost_saving = 0
@@ -569,8 +633,12 @@ class Mempool:
                 # find transactions small enough to fit at this point
                 if self.mempool_info.max_block_clvm_cost - cost_sum < MIN_COST_THRESHOLD:
                     break
+            except SkipDedup as e:
+                log.info(f"{e}")
+                continue
             except Exception as e:
                 log.info(f"Exception while checking a mempool item for deduplication: {e}")
+                skipped_items += 1
                 continue
         if processed_spend_bundles == 0:
             return None

chia/full_node/mempool_check_conditions.py

@@ -3,28 +3,27 @@ from __future__ import annotations
 import logging
 from typing import Optional
 
+from chia_puzzles_py.programs import CHIALISP_DESERIALISATION
 from chia_rs import (
+    ConsensusConstants,
     get_flags_for_height_and_constants,
     run_chia_program,
 )
 from chia_rs import get_puzzle_and_solution_for_coin2 as get_puzzle_and_solution_for_coin_rust
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 
-from chia.consensus.constants import ConsensusConstants
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_record import CoinRecord
 from chia.types.coin_spend import CoinSpend, CoinSpendWithConditions, SpendInfo, make_spend
 from chia.types.generator_types import BlockGenerator
 from chia.types.spend_bundle_conditions import SpendBundleConditions
 from chia.util.condition_tools import conditions_for_solution
 from chia.util.errors import Err
-from chia.util.ints import uint32, uint64
-from chia.wallet.puzzles.load_clvm import load_serialized_clvm_maybe_recompile
 
-DESERIALIZE_MOD = load_serialized_clvm_maybe_recompile(
-    "chialisp_deserialisation.clsp", package_or_requirement="chia.consensus.puzzles"
-)
+DESERIALIZE_MOD = Program.from_bytes(CHIALISP_DESERIALISATION)
+
 
 log = logging.getLogger(__name__)
 

chia/full_node/mempool_manager.py

@@ -5,14 +5,23 @@ import logging
 import time
 from collections.abc import Awaitable, Collection
 from concurrent.futures import Executor, ThreadPoolExecutor
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Callable, Optional, TypeVar
 
-from chia_rs import ELIGIBLE_FOR_DEDUP, ELIGIBLE_FOR_FF, BLSCache, supports_fast_forward, validate_clvm_and_signature
+from chia_rs import (
+    ELIGIBLE_FOR_DEDUP,
+    ELIGIBLE_FOR_FF,
+    BLSCache,
+    ConsensusConstants,
+    G2Element,
+    supports_fast_forward,
+    validate_clvm_and_signature,
+)
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 from chiabip158 import PyBIP158
 
 from chia.consensus.block_record import BlockRecordProtocol
-from chia.consensus.constants import ConsensusConstants
 from chia.consensus.cost_calculator import NPCResult
 from chia.full_node.bitcoin_fee_estimator import create_bitcoin_fee_estimator
 from chia.full_node.fee_estimation import FeeBlockInfo, MempoolInfo, MempoolItemInfo
@@ -21,11 +30,11 @@ from chia.full_node.mempool import MEMPOOL_ITEM_FEE_LIMIT, Mempool, MempoolRemov
 from chia.full_node.mempool_check_conditions import mempool_check_time_locks
 from chia.full_node.pending_tx_cache import ConflictTxCache, PendingTxCache
 from chia.types.blockchain_format.coin import Coin
-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.eligible_coin_spends import EligibilityAndAdditions, UnspentLineageInfo
 from chia.types.fee_rate import FeeRate
+from chia.types.generator_types import BlockGenerator
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.mempool_item import BundleCoinSpend, MempoolItem
 from chia.types.spend_bundle import SpendBundle
@@ -33,7 +42,6 @@ from chia.types.spend_bundle_conditions import SpendBundleConditions
 from chia.util.db_wrapper import SQLITE_INT_MAX
 from chia.util.errors import Err, ValidationError
 from chia.util.inline_executor import InlineExecutor
-from chia.util.ints import uint32, uint64
 
 log = logging.getLogger(__name__)
 
@@ -50,6 +58,24 @@ class TimelockConditions:
     assert_before_seconds: Optional[uint64] = None
 
 
+@dataclass
+class LineageInfoCache:
+    _fun: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]]
+    _cache: dict[bytes32, Optional[UnspentLineageInfo]] = field(default_factory=dict)
+
+    async def get_unspent_lineage_info(self, puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
+        # we rely on KeyError to distinguish between a stored
+        # None value and a missing entry
+        try:
+            return self._cache[puzzle_hash]
+        except KeyError:
+            pass
+
+        ret = await self._fun(puzzle_hash)
+        self._cache[puzzle_hash] = ret
+        return ret
+
+
 def compute_assert_height(
     removal_coin_records: dict[bytes32, CoinRecord],
     conds: SpendBundleConditions,
@@ -183,7 +209,7 @@ class MempoolManager:
         if single_threaded:
             self.pool = InlineExecutor()
         else:
-            self.pool = ThreadPoolExecutor(max_workers=2)
+            self.pool = ThreadPoolExecutor(max_workers=2, thread_name_prefix="mempool-")
 
         # The mempool will correspond to a certain peak
         self.peak: Optional[BlockRecordProtocol] = None
@@ -198,10 +224,10 @@ class MempoolManager:
     def shut_down(self) -> None:
         self.pool.shutdown(wait=True)
 
+    # TODO: remove this, use create_generator() instead
     async def create_bundle_from_mempool(
         self,
         last_tb_header_hash: bytes32,
-        get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
         item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
     ) -> Optional[tuple[SpendBundle, list[Coin]]]:
         """
@@ -209,16 +235,32 @@ class MempoolManager:
         additions and removals in that spend_bundle
         """
 
+        lineage_cache = LineageInfoCache(self.get_unspent_lineage_info_for_puzzle_hash)
+
+        if self.peak is None or self.peak.header_hash != last_tb_header_hash:
+            return None
+        return await self.mempool.create_bundle_from_mempool_items(
+            lineage_cache.get_unspent_lineage_info, self.constants, self.peak.height, item_inclusion_filter
+        )
+
+    async def create_block_generator(
+        self,
+        last_tb_header_hash: bytes32,
+        item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
+    ) -> Optional[tuple[BlockGenerator, G2Element, list[Coin], list[Coin]]]:
+        """
+        Returns a block generator program, the aggregate signature and all additions and removals, for a new block
+        """
         if self.peak is None or self.peak.header_hash != last_tb_header_hash:
             return None
-        if item_inclusion_filter is None:
 
-            def always(bundle_name: bytes32) -> bool:
-                return True
+        lineage_cache = LineageInfoCache(self.get_unspent_lineage_info_for_puzzle_hash)
 
-            item_inclusion_filter = always
-        return await self.mempool.create_bundle_from_mempool_items(
-            item_inclusion_filter, get_unspent_lineage_info_for_puzzle_hash, self.constants, self.peak.height
+        return await self.mempool.create_block_generator(
+            lineage_cache.get_unspent_lineage_info,
+            self.constants,
+            self.peak.height,
+            item_inclusion_filter,
         )
 
     def get_filter(self) -> bytes:
@@ -320,6 +362,9 @@ class MempoolManager:
         spend_name: bytes32,
         first_added_height: uint32,
         get_coin_records: Optional[Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]]] = None,
+        get_unspent_lineage_info_for_puzzle_hash: Optional[
+            Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]]
+        ] = None,
     ) -> SpendBundleAddInfo:
         """
         Validates and adds to mempool a new_spend with the given NPCResult, and spend_name, and the current mempool.
@@ -346,13 +391,17 @@ class MempoolManager:
 
         if get_coin_records is None:
             get_coin_records = self.get_coin_records
+
+        if get_unspent_lineage_info_for_puzzle_hash is None:
+            get_unspent_lineage_info_for_puzzle_hash = self.get_unspent_lineage_info_for_puzzle_hash
+
         err, item, remove_items = await self.validate_spend_bundle(
             new_spend,
             conds,
             spend_name,
             first_added_height,
             get_coin_records,
-            self.get_unspent_lineage_info_for_puzzle_hash,
+            get_unspent_lineage_info_for_puzzle_hash,
         )
         if err is None:
             # No error, immediately add to mempool, after removing conflicting TXs.
@@ -441,13 +490,16 @@ class MempoolManager:
                 EligibilityAndAdditions(is_eligible_for_dedup=False, spend_additions=[], ff_puzzle_hash=None),
             )
             mark_as_fast_forward = eligibility_info.ff_puzzle_hash is not None and supports_fast_forward(coin_spend)
+            latest_singleton_coin = None
             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:
+                lineage_info = await get_unspent_lineage_info_for_puzzle_hash(eligibility_info.ff_puzzle_hash)
+                if lineage_info is None:
                     return Err.DOUBLE_SPEND, None, []
+                latest_singleton_coin = lineage_info.coin_id
                 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):
@@ -457,6 +509,7 @@ class MempoolManager:
                 eligible_for_dedup=eligibility_info.is_eligible_for_dedup,
                 eligible_for_fast_forward=mark_as_fast_forward,
                 additions=eligibility_info.spend_additions,
+                latest_singleton_coin=latest_singleton_coin,
             )
 
         if removal_names != removal_names_from_coin_spends:
@@ -675,6 +728,8 @@ class MempoolManager:
         use_optimization: bool = self.peak is not None and new_peak.prev_transaction_block_hash == self.peak.header_hash
         self.peak = new_peak
 
+        lineage_cache = LineageInfoCache(self.get_unspent_lineage_info_for_puzzle_hash)
+
         if use_optimization and spent_coins is not None:
             # We don't reinitialize a mempool, just kick removed items
             # transactions in the mempool may be spending multiple coins,
@@ -682,12 +737,81 @@ class MempoolManager:
             # find the same transaction multiple times. We put them in a set
             # to deduplicate
             spendbundle_ids_to_remove: set[bytes32] = set()
+
+            # rebasing a fast forward spend is more expensive than to just
+            # evict the item. So, any FF spend we may need to rebase, defer
+            # them until after we've gone through all spends
+            deferred_ff_items: set[tuple[bytes32, bytes32]] = set()
+
             for spend in spent_coins:
                 items = self.mempool.get_items_by_coin_id(spend)
                 for item in items:
-                    included_items.append(MempoolItemInfo(item.cost, item.fee, item.height_added_to_mempool))
-                    self.remove_seen(item.name)
-                    spendbundle_ids_to_remove.add(item.name)
+                    # this is a property, compute it once
+                    item_name = item.name
+
+                    # if we've already decided to remove this mempool item
+                    # because of some other coin, we don't need to do any more
+                    # work
+                    if item_name in spendbundle_ids_to_remove:
+                        continue
+
+                    bcs = item.bundle_coin_spends.get(spend)
+                    if bcs is not None and bcs.latest_singleton_coin is None:
+                        # this is a regular coin spend that's now made it into
+                        # a block and we just evict its mempool item
+                        included_items.append(MempoolItemInfo(item.cost, item.fee, item.height_added_to_mempool))
+                        self.remove_seen(item_name)
+                        spendbundle_ids_to_remove.add(item_name)
+                        continue
+
+                    deferred_ff_items.add((spend, item_name))
+
+            # fast forward spends are indexed under the latest singleton coin ID
+            # if it's spent, we need to update the index in the mempool. This
+            # list lets us perform a bulk update
+            # new_coin_id, current_coin_id, mempool item name
+            spends_to_update: list[tuple[bytes32, bytes32, bytes32]] = []
+
+            for spend, item_name in deferred_ff_items:
+                if item_name in spendbundle_ids_to_remove:
+                    continue
+                # there may be multiple matching spends in the mempool
+                # item, for the same singleton
+                found_matches = 0
+                for bcs in item.bundle_coin_spends.values():
+                    if bcs.latest_singleton_coin != spend:
+                        continue
+                    found_matches += 1
+
+                    # TODO: in the future, we could pass this new coin ID
+                    # into new_peak() and avoid this DB lookup
+                    lineage_info = await lineage_cache.get_unspent_lineage_info(bcs.coin_spend.coin.puzzle_hash)
+                    if lineage_info is None:
+                        # this singleton no longer has an unspent coin with
+                        # this puzzle-hash. FF is not longer available and we
+                        # just need to evict this mempool item
+                        self.remove_seen(item_name)
+                        spendbundle_ids_to_remove.add(item_name)
+                        break
+
+                    spends_to_update.append((lineage_info.coin_id, spend, item_name))
+                    bcs.latest_singleton_coin = lineage_info.coin_id
+
+                if found_matches == 0:  # pragma: no cover
+                    # We are not expected to get here. this is all
+                    # defensive to get rid of the spend bundle or patch
+                    # it up
+                    log.warning(
+                        f"MempoolItem indexed as spending coin: {spend}, "
+                        f"but spend is not found in item: {item_name}. Evicting mempool item"
+                    )
+                    # we don't expect this to happen, so evict the
+                    # item as a precaution
+                    spendbundle_ids_to_remove.add(item_name)
+
+            if len(spends_to_update) > 0:
+                self.mempool.update_spend_index(spends_to_update)
+
             mempool_item_removals.append(
                 self.mempool.remove_from_pool(list(spendbundle_ids_to_remove), MempoolRemoveReason.BLOCK_INCLUSION)
             )
@@ -730,6 +854,7 @@ class MempoolManager:
                     item.spend_bundle_name,
                     item.height_added_to_mempool,
                     local_get_coin_records,
+                    lineage_cache.get_unspent_lineage_info,
                 )
                 # Only add to `seen` if inclusion worked, so it can be resubmitted in case of a reorg
                 if info.status == MempoolInclusionStatus.SUCCESS:
@@ -751,6 +876,7 @@ class MempoolManager:
                 item.spend_bundle_name,
                 item.height_added_to_mempool,
                 self.get_coin_records,
+                lineage_cache.get_unspent_lineage_info,
             )
             if info.status == MempoolInclusionStatus.SUCCESS:
                 txs_added.append(NewPeakItem(item.spend_bundle_name, item.spend_bundle, item.conds))
@@ -808,6 +934,13 @@ def can_replace(
     assert_height: Optional[uint32] = None
     assert_before_height: Optional[uint32] = None
     assert_before_seconds: Optional[uint64] = None
+    # we don't allow replacing mempool items with new ones that remove
+    # eligibility for dedup and fast-forward. Doing so could be abused by
+    # denying such spends from operating as intended
+    # collect all coins that are eligible for dedup and FF in the existing items
+    existing_ff_spends: set[bytes32] = set()
+    existing_dedup_spends: set[bytes32] = set()
+
     for item in conflicting_items:
         conflicting_fees += item.fee
         conflicting_cost += item.cost
@@ -817,10 +950,14 @@ def can_replace(
         # bundle with AB with a higher fee. An attacker then replaces the bundle with just B with a higher
         # fee than AB therefore kicking out A altogether. The better way to solve this would be to keep a cache
         # of booted transactions like A, and retry them after they get removed from mempool due to a conflict.
-        for coin in item.removals:
-            if coin.name() not in removal_names:
-                log.debug(f"Rejecting conflicting tx as it does not spend conflicting coin {coin.name()}")
+        for coin_id, bcs in item.bundle_coin_spends.items():
+            if coin_id not in removal_names:
+                log.debug("Rejecting conflicting tx as it does not spend conflicting coin %s", coin_id)
                 return False
+            if bcs.eligible_for_fast_forward:
+                existing_ff_spends.add(bytes32(coin_id))
+            if bcs.eligible_for_dedup:
+                existing_dedup_spends.add(bytes32(coin_id))
 
         assert_height = optional_max(assert_height, item.assert_height)
         assert_before_height = optional_min(assert_before_height, item.assert_before_height)
@@ -866,5 +1003,15 @@ def can_replace(
         )
         return False
 
+    if len(existing_ff_spends) > 0 or len(existing_dedup_spends) > 0:
+        for coin_id, bcs in new_item.bundle_coin_spends.items():
+            if not bcs.eligible_for_fast_forward and coin_id in existing_ff_spends:
+                log.debug("Rejecting conflicting tx due to changing ELIGIBLE_FOR_FF of coin spend %s", coin_id)
+                return False
+
+            if not bcs.eligible_for_dedup and coin_id in existing_dedup_spends:
+                log.debug("Rejecting conflicting tx due to changing ELIGIBLE_FOR_DEDUP of coin spend %s", coin_id)
+                return False
+
     log.info(f"Replacing conflicting tx in mempool. New tx fee: {new_item.fee}, old tx fees: {conflicting_fees}")
     return True

chia/full_node/pending_tx_cache.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Optional
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32
 from sortedcontainers import SortedDict
 
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.mempool_item import MempoolItem
-from chia.util.ints import uint32
 
 
 @dataclass

chia/full_node/subscriptions.py

@@ -4,10 +4,10 @@ import logging
 from dataclasses import dataclass, field
 
 from chia_rs import Coin
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
 
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.spend_bundle_conditions import SpendBundleConditions
-from chia.util.ints import uint64
 
 log = logging.getLogger(__name__)
 

chia/full_node/sync_store.py

@@ -9,9 +9,8 @@ from dataclasses import dataclass, field
 from typing import Optional
 
 import typing_extensions
-
-from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.ints import uint32, uint128
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint128
 
 log = logging.getLogger(__name__)
 

chia/full_node/tx_processing_queue.py

@@ -6,7 +6,8 @@ from dataclasses import dataclass
 from queue import SimpleQueue
 from typing import Optional
 
-from chia.types.blockchain_format.sized_bytes import bytes32
+from chia_rs.sized_bytes import bytes32
+
 from chia.types.transaction_queue_entry import TransactionQueueEntry
 
 

chia/full_node/weight_proof.py

@@ -10,10 +10,13 @@ from concurrent.futures.process import ProcessPoolExecutor
 from multiprocessing.context import BaseContext
 from typing import IO, Optional
 
+from chia_rs import ConsensusConstants, SubEpochChallengeSegment, SubEpochData, SubEpochSegments, SubSlotData
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint32, uint64, uint128
+
 from chia.consensus.block_header_validation import validate_finished_header_block
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockchainInterface
-from chia.consensus.constants import ConsensusConstants
 from chia.consensus.deficit import calculate_deficit
 from chia.consensus.full_block_to_block_record import header_block_to_sub_block_record
 from chia.consensus.pot_iterations import (
@@ -25,7 +28,6 @@ from chia.consensus.pot_iterations import (
 from chia.consensus.vdf_info_computation import get_signage_point_vdf_info
 from chia.types.blockchain_format.classgroup import ClassgroupElement
 from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.blockchain_format.slots import ChallengeChainSubSlot, RewardChainSubSlot
 from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof, validate_vdf
@@ -34,16 +36,11 @@ from chia.types.header_block import HeaderBlock
 from chia.types.validation_state import ValidationState
 from chia.types.weight_proof import (
     RecentChainData,
-    SubEpochChallengeSegment,
-    SubEpochData,
-    SubEpochSegments,
-    SubSlotData,
     WeightProof,
 )
 from chia.util.batches import to_batches
 from chia.util.block_cache import BlockCache
 from chia.util.hash import std_hash
-from chia.util.ints import uint8, uint32, uint64, uint128
 from chia.util.setproctitle import getproctitle, setproctitle
 from chia.util.task_referencer import create_referenced_task
 
@@ -647,7 +644,7 @@ class WeightProofHandler:
             fork_point_index = idx
 
         if fork_point_index <= 2:
-            # Two summeries can have different blocks and still be identical
+            # Two summaries can have different blocks and still be identical
             # This gets resolved after one full sub epoch
             return uint32(0), 0
 

chia/harvester/harvester.py

@@ -10,9 +10,10 @@ from concurrent.futures.thread import ThreadPoolExecutor
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
+from chia_rs import ConsensusConstants
+from chia_rs.sized_ints import uint32
 from typing_extensions import Literal
 
-from chia.consensus.constants import ConsensusConstants
 from chia.plot_sync.sender import Sender
 from chia.plotting.manager import PlotManager
 from chia.plotting.util import (
@@ -40,7 +41,6 @@ from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.util.cpu import available_logical_cores
-from chia.util.ints import uint32
 
 log = logging.getLogger(__name__)
 
@@ -94,7 +94,9 @@ class Harvester:
             root_path, refresh_parameter=refresh_parameter, refresh_callback=self._plot_refresh_callback
         )
         self._shut_down = False
-        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=config["num_threads"])
+        self.executor = concurrent.futures.ThreadPoolExecutor(
+            max_workers=config["num_threads"], thread_name_prefix="harvester-"
+        )
         self._server = None
         self.constants = constants
         self.state_changed_callback: Optional[StateChangedProtocol] = None