chia-blockchain 2.5.3rc1__py3-none-any.whl → 2.5.4rc1__py3-none-any.whl

chia/_tests/core/mempool/test_mempool.py

@@ -2959,7 +2959,7 @@ async def test_skip_error_items() -> None:
 
     result = await mempool.create_block_generator(local_get_unspent_lineage_info, DEFAULT_CONSTANTS, uint32(10))
     assert result is not None
-    generator, _, _ = result
+    generator, _, _, _ = result
 
     assert called == 3
     assert generator.program == SerializedProgram.from_bytes(bytes.fromhex("ff01ff8080"))
@@ -3249,7 +3249,7 @@ async def test_create_block_generator() -> None:
 
     block = await mempool.create_block_generator(get_unspent_lineage_info_for_puzzle_hash, test_constants, uint32(0))
     assert block is not None
-    generator, signature, additions = block
+    generator, signature, additions, _ = block
 
     assert set(additions) == expected_additions
 

chia/_tests/core/mempool/test_mempool_manager.py

@@ -19,7 +19,7 @@ from chia_rs.sized_ints import uint8, uint32, uint64
 from chiabip158 import PyBIP158
 
 from chia._tests.conftest import ConsensusMode
-from chia._tests.util.misc import invariant_check_mempool
+from chia._tests.util.misc import Marks, datacases, invariant_check_mempool
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets, setup_simulators_and_wallets
 from chia.consensus.condition_costs import ConditionCost
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
@@ -32,7 +32,10 @@ from chia.full_node.mempool_manager import (
     MempoolManager,
     TimelockConditions,
     can_replace,
+    check_removals,
     compute_assert_height,
+    is_atom_canonical,
+    is_clvm_canonical,
     optional_max,
     optional_min,
 )
@@ -87,6 +90,74 @@ TEST_COIN_RECORD3 = CoinRecord(TEST_COIN3, uint32(0), uint32(0), False, TEST_TIM
 TEST_HEIGHT = uint32(5)
 
 
+@pytest.mark.parametrize("clvm_hex", ["80", "ff8080", "ff7f03", "ffff8080ff8080"])
+def test_clvm_canonical(clvm_hex: str) -> None:
+    clvm_buf = bytes.fromhex(clvm_hex)
+    assert is_clvm_canonical(clvm_buf)
+
+
+@pytest.mark.parametrize(
+    "clvm_hex",
+    [
+        "fffe80",
+        "c000",
+        "c03f",
+        "e00000",
+        "e01fff",
+        "f0000000",
+        "f00fffff",
+        "f800000000",
+        "f807ffffff",
+        "fc0000000000",
+        "fc03ffffffff",
+        "fe",
+        "ff808080",
+    ],
+)
+def test_clvm_not_canonical(clvm_hex: str) -> None:
+    clvm_buf = bytes.fromhex(clvm_hex)
+    assert not is_clvm_canonical(clvm_buf)
+
+
+@pytest.mark.parametrize(
+    "clvm_hex, expect",
+    [
+        ("c000", 2 + 0),
+        ("c03f", 2 + 0x3F),
+        ("e00000", 3 + 0),
+        ("e01fff", 3 + 0x1FFF),
+        ("f0000000", 4 + 0),
+        ("f00fffff", 4 + 0xFFFFF),
+        ("f800000000", 5 + 0),
+        ("f807ffffff", 5 + 0x7FFFFFF),
+        ("fc0000000000", 6 + 0),
+        ("fc03ffffffff", 6 + 0x3FFFFFFFF),
+    ],
+)
+def test_atom_not_canonical(clvm_hex: str, expect: int) -> None:
+    clvm_buf = bytes.fromhex(clvm_hex)
+    atom_len, is_canonical = is_atom_canonical(clvm_buf, 0)
+    assert atom_len == expect
+    assert not is_canonical
+
+
+@pytest.mark.parametrize(
+    "clvm_hex, expect",
+    [
+        ("c040", 2 + 0x40),
+        ("e02000", 3 + 0x2000),
+        ("f0100000", 4 + 0x100000),
+        ("f808000000", 5 + 0x8000000),
+        ("fc0400000000", 6 + 0x400000000),
+    ],
+)
+def test_atom_canonical(clvm_hex: str, expect: int) -> None:
+    clvm_buf = bytes.fromhex(clvm_hex)
+    atom_len, is_canonical = is_atom_canonical(clvm_buf, 0)
+    assert atom_len == expect
+    assert is_canonical
+
+
 @dataclasses.dataclass(frozen=True)
 class TestBlockRecord:
     """
@@ -195,6 +266,9 @@ async def setup_mempool_with_coins(
     return (mempool_manager, coins)
 
 
+CreateCoin = tuple[bytes32, int, Optional[bytes]]
+
+
 def make_test_conds(
     *,
     birth_height: Optional[int] = None,
@@ -209,13 +283,18 @@ def make_test_conds(
     before_seconds_absolute: Optional[int] = None,
     cost: int = 0,
     spend_ids: Sequence[tuple[Union[bytes32, Coin], int]] = [(TEST_COIN_ID, 0)],
+    created_coins: Optional[list[list[CreateCoin]]] = None,
 ) -> SpendBundleConditions:
-    spend_info: list[tuple[bytes32, bytes32, bytes32, uint64, int]] = []
-    for coin, flags in spend_ids:
+    if created_coins is None:
+        created_coins = []
+    if len(created_coins) < len(spend_ids):
+        created_coins.extend([[] for _ in range(len(spend_ids) - len(created_coins))])
+    spend_info: list[tuple[bytes32, bytes32, bytes32, uint64, int, list[CreateCoin]]] = []
+    for (coin, flags), create_coin in zip(spend_ids, created_coins):
         if isinstance(coin, Coin):
-            spend_info.append((coin.name(), coin.parent_coin_info, coin.puzzle_hash, coin.amount, flags))
+            spend_info.append((coin.name(), coin.parent_coin_info, coin.puzzle_hash, coin.amount, flags, create_coin))
         else:
-            spend_info.append((coin, IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT, flags))
+            spend_info.append((coin, IDENTITY_PUZZLE_HASH, IDENTITY_PUZZLE_HASH, TEST_COIN_AMOUNT, flags, create_coin))
 
     return SpendBundleConditions(
         [
@@ -230,7 +309,7 @@ def make_test_conds(
                 None if before_seconds_relative is None else uint64(before_seconds_relative),
                 None if birth_height is None else uint32(birth_height),
                 None if birth_seconds is None else uint64(birth_seconds),
-                [],
+                create_coin,
                 [],
                 [],
                 [],
@@ -240,7 +319,7 @@ def make_test_conds(
                 [],
                 flags,
             )
-            for coin_id, parent_id, puzzle_hash, amount, flags in spend_info
+            for coin_id, parent_id, puzzle_hash, amount, flags, create_coin in spend_info
         ],
         0,
         uint32(height_absolute),
@@ -751,6 +830,23 @@ def test_optional_max() -> None:
     assert optional_max(uint32(123), uint32(234)) == uint32(234)
 
 
+def mk_coin_spend(coin: Coin, solution: Optional[str] = None) -> CoinSpend:
+    return make_spend(
+        coin,
+        SerializedProgram.to(None),
+        SerializedProgram.fromhex(solution if solution is not None else "80"),
+    )
+
+
+def mk_bcs(coin_spend: CoinSpend, flags: int = 0) -> BundleCoinSpend:
+    return BundleCoinSpend(
+        coin_spend=coin_spend,
+        eligible_for_dedup=bool(flags & ELIGIBLE_FOR_DEDUP),
+        eligible_for_fast_forward=bool(flags & ELIGIBLE_FOR_FF),
+        additions=[],
+    )
+
+
 def mk_item(
     coins: list[Coin],
     *,
@@ -759,6 +855,7 @@ def mk_item(
     assert_height: Optional[int] = None,
     assert_before_height: Optional[int] = None,
     assert_before_seconds: Optional[int] = None,
+    solution: Optional[str] = None,
     flags: list[int] = [],
 ) -> MempoolItem:
     # we don't actually care about the puzzle and solutions for the purpose of
@@ -771,14 +868,10 @@ def mk_item(
     for c, f in zip(coins, flags):
         coin_id = c.name()
         spend_ids.append((coin_id, f))
-        spend = make_spend(c, SerializedProgram.to(None), SerializedProgram.to(None))
-        coin_spends.append(spend)
-        bundle_coin_spends[coin_id] = BundleCoinSpend(
-            coin_spend=spend,
-            eligible_for_dedup=bool(f & ELIGIBLE_FOR_DEDUP),
-            eligible_for_fast_forward=bool(f & ELIGIBLE_FOR_FF),
-            additions=[],
-        )
+        coin_spend = mk_coin_spend(c, solution=solution)
+        solution = None
+        coin_spends.append(coin_spend)
+        bundle_coin_spends[coin_id] = mk_bcs(coin_spend, f)
     spend_bundle = SpendBundle(coin_spends, G2Element())
     conds = make_test_conds(cost=cost, spend_ids=spend_ids)
     return MempoolItem(
@@ -1625,6 +1718,7 @@ async def test_coin_spending_different_ways_then_finding_it_spent_in_new_peak(ne
 
     mempool_manager = await instantiate_mempool_manager(get_coin_records)
     # Create a bunch of mempool items that spend the coin in different ways
+    # only the first one will be accepted
     for i in range(3):
         _, _, result = await generate_and_add_spendbundle(
             mempool_manager,
@@ -1634,10 +1728,13 @@ async def test_coin_spending_different_ways_then_finding_it_spent_in_new_peak(ne
             ],
             coin,
         )
-        assert result[1] == MempoolInclusionStatus.SUCCESS
-    assert len(list(mempool_manager.mempool.get_items_by_coin_id(coin_id))) == 3
-    assert mempool_manager.mempool.size() == 3
-    assert len(list(mempool_manager.mempool.items_by_feerate())) == 3
+        if i == 0:
+            assert result[1] == MempoolInclusionStatus.SUCCESS
+        else:
+            assert result[1] == MempoolInclusionStatus.PENDING
+    assert len(list(mempool_manager.mempool.get_items_by_coin_id(coin_id))) == 1
+    assert mempool_manager.mempool.size() == 1
+    assert len(list(mempool_manager.mempool.items_by_feerate())) == 1
     # Setup a new peak where the incoming block has spent the coin
     # Mark this coin as spent
     test_coin_records = {coin_id: CoinRecord(coin, uint32(0), TEST_HEIGHT, False, uint64(0))}
@@ -1816,7 +1913,7 @@ async def test_identical_spend_aggregation_e2e(
     sb_ef_name = sb_ef.name()
     await send_to_mempool(full_node_api, sb_ef)
     # Send also a transaction EG that spends E differently from DE and EF,
-    # so that it doesn't get deduplicated on E with them
+    # to ensure it's rejected by the mempool
     conditions = [
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, e_coin.amount],
         [ConditionOpcode.ASSERT_MY_COIN_ID, e_coin.name()],
@@ -1834,14 +1931,13 @@ async def test_identical_spend_aggregation_e2e(
     [tx_g] = action_scope.side_effects.transactions
     assert tx_g.spend_bundle is not None
     sb_e2g = SpendBundle.aggregate([sb_e2, tx_g.spend_bundle])
-    sb_e2g_name = sb_e2g.name()
-    await send_to_mempool(full_node_api, sb_e2g)
+    await send_to_mempool(full_node_api, sb_e2g, expecting_conflict=True)
 
     # Make sure our coin IDs to spend bundles mappings are correct
     assert get_sb_names_by_coin_id(full_node_api, coins[4].coin.name()) == {sb_de_name}
-    assert get_sb_names_by_coin_id(full_node_api, e_coin_id) == {sb_de_name, sb_ef_name, sb_e2g_name}
+    assert get_sb_names_by_coin_id(full_node_api, e_coin_id) == {sb_de_name, sb_ef_name}
     assert get_sb_names_by_coin_id(full_node_api, coins[5].coin.name()) == {sb_ef_name}
-    assert get_sb_names_by_coin_id(full_node_api, g_coin_id) == {sb_e2g_name}
+    assert get_sb_names_by_coin_id(full_node_api, g_coin_id) == set()
 
     await farm_a_block(full_node_api, wallet_node, ph)
 
@@ -2501,3 +2597,215 @@ async def test_advancing_ff(use_optimization: bool) -> None:
     spend = item.bundle_coin_spends[spend_a.coin.name()]
     assert spend.eligible_for_fast_forward
     assert spend.latest_singleton_coin == spend_c.coin.name()
+
+
+@pytest.mark.parametrize("flags", [ELIGIBLE_FOR_DEDUP, ELIGIBLE_FOR_FF, ELIGIBLE_FOR_FF | ELIGIBLE_FOR_DEDUP])
+@pytest.mark.anyio
+async def test_check_removals_with_block_creation(flags: int) -> None:
+    LAUNCHER_ID = bytes32([1] * 32)
+    PARENT_PARENT = bytes32([2] * 32)
+    singleton_spend = make_singleton_spend(LAUNCHER_ID, PARENT_PARENT)
+    coins = TestCoins(
+        coins=[singleton_spend.coin, TEST_COIN], lineage={singleton_spend.coin.puzzle_hash: singleton_spend.coin}
+    )
+    mempool_manager = await setup_mempool(coins)
+    sb1 = SpendBundle([singleton_spend], G2Element())
+    sb1_conds = make_test_conds(
+        spend_ids=[(singleton_spend.coin, 0)],
+        created_coins=[[(singleton_spend.coin.puzzle_hash, 1, None)]],
+        cost=100_000_000,
+    )
+    bundle_add_info1 = await mempool_manager.add_spend_bundle(sb1, sb1_conds, sb1.name(), uint32(1))
+    assert bundle_add_info1.status == MempoolInclusionStatus.SUCCESS
+    invariant_check_mempool(mempool_manager.mempool)
+    extra_spend = make_spend(
+        TEST_COIN, IDENTITY_PUZZLE, Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 42]])
+    )
+    sb2 = SpendBundle([singleton_spend, extra_spend], G2Element())
+    sb2_conds = make_test_conds(
+        spend_ids=[(singleton_spend.coin, flags), (TEST_COIN, 0)],
+        created_coins=[[(singleton_spend.coin.puzzle_hash, 1, None)], []],
+        cost=1337,
+    )
+    bundle_add_info2 = await mempool_manager.add_spend_bundle(sb2, sb2_conds, sb2.name(), uint32(1))
+    assert bundle_add_info2.status == MempoolInclusionStatus.SUCCESS
+    assert mempool_manager.peak is not None
+    block_generator = await mempool_manager.create_block_generator(mempool_manager.peak.header_hash)
+    assert block_generator is not None
+    _, _, additions, removals = block_generator
+    assert len(additions) == 1
+    assert set(additions) == {Coin(singleton_spend.coin.name(), singleton_spend.coin.puzzle_hash, uint64(1))}
+    assert len(removals) == 2
+    assert set(removals) == {singleton_spend.coin, TEST_COIN}
+
+
+@pytest.mark.anyio
+async def test_dedup_not_canonical() -> None:
+    # this is ((1)), but with a non-canonical encoding
+    coin_spend = mk_coin_spend(TEST_COIN, solution="ffffc001018080")
+    coins = TestCoins([TEST_COIN], lineage={})
+    mempool_manager = await setup_mempool(coins)
+    sb = SpendBundle([coin_spend], G2Element())
+    sb_conds = make_test_conds(spend_ids=[(TEST_COIN, ELIGIBLE_FOR_DEDUP)])
+    bundle_add_info = await mempool_manager.add_spend_bundle(sb, sb_conds, sb.name(), uint32(1))
+    assert bundle_add_info.status == MempoolInclusionStatus.FAILED
+    assert bundle_add_info.error == Err.INVALID_COIN_SOLUTION
+
+
+def make_coin_record(coin: Coin, spent_block_index: int = 0) -> CoinRecord:
+    return CoinRecord(coin, uint32(0), uint32(spent_block_index), False, TEST_TIMESTAMP)
+
+
+@dataclasses.dataclass
+class CheckRemovalsCase:
+    id: str
+    removals: dict[bytes32, CoinRecord]
+    bundle_coin_spends: dict[bytes32, BundleCoinSpend] = dataclasses.field(default_factory=dict)
+    conflicting_mempool_items: dict[bytes32, list[MempoolItem]] = dataclasses.field(default_factory=dict)
+    expected_result: tuple[Optional[Err], list[MempoolItem]] = dataclasses.field(default_factory=lambda: (None, []))
+    marks: Marks = ()
+
+
+@datacases(
+    CheckRemovalsCase(
+        id="No removals",
+        removals={},
+        expected_result=(None, []),
+    ),
+    CheckRemovalsCase(
+        id="Unspent removal, no mempool conflicts",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD},
+        bundle_coin_spends={TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN))},
+        expected_result=(None, []),
+    ),
+    CheckRemovalsCase(
+        id="Already spent non FF coin",
+        removals={TEST_COIN_ID: make_coin_record(TEST_COIN, spent_block_index=1)},
+        bundle_coin_spends={TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN))},
+        expected_result=(Err.DOUBLE_SPEND, []),
+    ),
+    CheckRemovalsCase(
+        id="Already spent FF coin, no mempool conflicts",
+        removals={TEST_COIN_ID: make_coin_record(TEST_COIN, spent_block_index=1)},
+        bundle_coin_spends={TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN), ELIGIBLE_FOR_FF)},
+        expected_result=(None, []),
+    ),
+    CheckRemovalsCase(
+        id="FF coin, non FF mempool conflict",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD},
+        bundle_coin_spends={TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN), ELIGIBLE_FOR_FF)},
+        conflicting_mempool_items={TEST_COIN_ID: [mk_item([TEST_COIN])]},
+        expected_result=(Err.MEMPOOL_CONFLICT, [mk_item([TEST_COIN])]),
+    ),
+    CheckRemovalsCase(
+        id="Dedup coin, non dedup mempool conflict",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD},
+        bundle_coin_spends={TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN), ELIGIBLE_FOR_DEDUP)},
+        conflicting_mempool_items={TEST_COIN_ID: [mk_item([TEST_COIN])]},
+        expected_result=(Err.MEMPOOL_CONFLICT, [mk_item([TEST_COIN])]),
+    ),
+    CheckRemovalsCase(
+        id="FF coin, FF mempool conflict",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD},
+        bundle_coin_spends={TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN), ELIGIBLE_FOR_FF)},
+        conflicting_mempool_items={TEST_COIN_ID: [mk_item([TEST_COIN], flags=[ELIGIBLE_FOR_FF])]},
+        expected_result=(None, []),
+    ),
+    CheckRemovalsCase(
+        id="Dedup coin, Dedup mempool conflict",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD},
+        bundle_coin_spends={TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN), ELIGIBLE_FOR_DEDUP)},
+        conflicting_mempool_items={TEST_COIN_ID: [mk_item([TEST_COIN], flags=[ELIGIBLE_FOR_DEDUP])]},
+        expected_result=(None, []),
+    ),
+    CheckRemovalsCase(
+        id="Dedup coin, Dedup mempool conflict with different solution",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD},
+        bundle_coin_spends={TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN, solution="ff8080"), ELIGIBLE_FOR_DEDUP)},
+        conflicting_mempool_items={TEST_COIN_ID: [mk_item([TEST_COIN], flags=[ELIGIBLE_FOR_DEDUP])]},
+        expected_result=(
+            Err.MEMPOOL_CONFLICT,
+            [
+                mk_item(
+                    [TEST_COIN],
+                    flags=[ELIGIBLE_FOR_DEDUP],
+                )
+            ],
+        ),
+    ),
+    CheckRemovalsCase(
+        id="Regular coin, mempool conflict",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD},
+        bundle_coin_spends={TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN))},
+        conflicting_mempool_items={TEST_COIN_ID: [mk_item([TEST_COIN])]},
+        expected_result=(Err.MEMPOOL_CONFLICT, [mk_item([TEST_COIN])]),
+    ),
+    CheckRemovalsCase(
+        id="Both FF and non FF coins, FF one conflicts with existing non FF",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD, TEST_COIN_ID2: TEST_COIN_RECORD2},
+        bundle_coin_spends={
+            TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN)),
+            TEST_COIN_ID2: mk_bcs(mk_coin_spend(TEST_COIN2), ELIGIBLE_FOR_FF),
+        },
+        conflicting_mempool_items={TEST_COIN_ID: [mk_item([TEST_COIN])], TEST_COIN_ID2: [mk_item([TEST_COIN2])]},
+        expected_result=(Err.MEMPOOL_CONFLICT, [mk_item([TEST_COIN]), mk_item([TEST_COIN2])]),
+    ),
+    CheckRemovalsCase(
+        id="Both FF and non FF coins, FF one conflicts with existing FF",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD, TEST_COIN_ID2: TEST_COIN_RECORD2},
+        bundle_coin_spends={
+            TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN)),
+            TEST_COIN_ID2: mk_bcs(mk_coin_spend(TEST_COIN2), ELIGIBLE_FOR_FF),
+        },
+        conflicting_mempool_items={
+            TEST_COIN_ID: [mk_item([TEST_COIN])],
+            TEST_COIN_ID2: [mk_item([TEST_COIN2], flags=[ELIGIBLE_FOR_FF])],
+        },
+        expected_result=(Err.MEMPOOL_CONFLICT, [mk_item([TEST_COIN])]),
+    ),
+    CheckRemovalsCase(
+        id="Two FF coins, only one with non FF conflict",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD, TEST_COIN_ID2: TEST_COIN_RECORD2},
+        bundle_coin_spends={
+            TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN), ELIGIBLE_FOR_FF),
+            TEST_COIN_ID2: mk_bcs(mk_coin_spend(TEST_COIN2), ELIGIBLE_FOR_FF),
+        },
+        conflicting_mempool_items={
+            TEST_COIN_ID: [mk_item([TEST_COIN], flags=[ELIGIBLE_FOR_FF])],
+            TEST_COIN_ID2: [mk_item([TEST_COIN2])],
+        },
+        expected_result=(Err.MEMPOOL_CONFLICT, [mk_item([TEST_COIN2])]),
+    ),
+    CheckRemovalsCase(
+        id="Conflicting items are added to conflicts only once",
+        removals={TEST_COIN_ID: TEST_COIN_RECORD, TEST_COIN_ID2: TEST_COIN_RECORD2},
+        bundle_coin_spends={
+            TEST_COIN_ID: mk_bcs(mk_coin_spend(TEST_COIN)),
+            TEST_COIN_ID2: mk_bcs(mk_coin_spend(TEST_COIN2)),
+        },
+        # Same item spends both coins
+        conflicting_mempool_items={
+            TEST_COIN_ID: [mk_item([TEST_COIN, TEST_COIN2])],
+            TEST_COIN_ID2: [mk_item([TEST_COIN, TEST_COIN2])],
+        },
+        # Item should be added only once in conflicts
+        expected_result=(Err.MEMPOOL_CONFLICT, [mk_item([TEST_COIN, TEST_COIN2])]),
+    ),
+)
+def test_check_removals(case: CheckRemovalsCase) -> None:
+    def test_get_items_by_coin_ids(coin_ids: list[bytes32]) -> list[MempoolItem]:
+        items = set()
+        for coin_id in coin_ids:
+            items.update(case.conflicting_mempool_items.get(coin_id, []))
+        return list(items)
+
+    result = check_removals(
+        bundle_coin_spends=case.bundle_coin_spends,
+        removals=case.removals,
+        get_items_by_coin_ids=test_get_items_by_coin_ids,
+    )
+    expected_err, expected_conflicts = case.expected_result
+    err, conflicts = result
+    assert err == expected_err
+    assert len(conflicts) == len(expected_conflicts)
+    assert set(conflicts) == set(expected_conflicts)

chia/_tests/timelord/test_new_peak.py

@@ -348,6 +348,64 @@ class TestNewPeak:
                     == new_peak.reward_chain_block.get_hash()
                 )
 
+    @pytest.mark.anyio
+    async def test_timelord_new_peak_node_sync(
+        self,
+        one_node: tuple[list[FullNodeService], list[FullNodeSimulator], BlockTools],
+        timelord: tuple[TimelordAPI, ChiaServer],
+        default_1000_blocks: list[FullBlock],
+    ) -> None:
+        [full_node_service], _, bt = one_node
+        full_node = full_node_service._node
+        async with create_blockchain(bt.constants, 2) as (b1, _):
+            async with create_blockchain(bt.constants, 2) as (b2, _):
+                timelord_api, _ = timelord
+                for block in default_1000_blocks:
+                    await _validate_and_add_block(b1, block)
+                    await _validate_and_add_block(b2, block)
+                    await full_node.add_block(block)
+
+                peak = timelord_peak_from_block(b1, default_1000_blocks[-1])
+                assert peak is not None
+                assert timelord_api.timelord.new_peak is None
+                await timelord_api.new_peak_timelord(peak)
+                assert timelord_api.timelord.new_peak is not None
+                assert (
+                    timelord_api.timelord.new_peak.reward_chain_block.get_hash() == peak.reward_chain_block.get_hash()
+                )
+                await time_out_assert(60, peak_new_peak_is_none, True, timelord_api)
+                # make two new blocks on tip, block_2 has higher total iterations
+                block_1 = bt.get_consecutive_blocks(1, default_1000_blocks)[-1]
+                block_2 = bt.get_consecutive_blocks(
+                    1, default_1000_blocks, min_signage_point=block_1.reward_chain_block.signage_point_index
+                )[-1]
+                assert block_2.weight == block_1.weight
+                # make sure block_2 has higher iterations then block_1
+                assert block_2.total_iters > block_1.total_iters
+                # make sure block_1 and block_2 have higher iterations then peak
+                assert block_1.total_iters > default_1000_blocks[-1].total_iters
+                await full_node.add_block(block_2)
+                await _validate_and_add_block(b1, block_2)
+                peak_tl = timelord_peak_from_block(b1, block_2)
+                peak = await full_node.blockchain.get_full_peak()
+                assert peak is not None
+                assert timelord_api.timelord.new_peak is None
+                await timelord_api.new_peak_timelord(peak_tl)
+                assert timelord_api.timelord.new_peak is not None
+                assert peak.header_hash == block_2.header_hash
+                assert peak_tl.reward_chain_block.get_hash() == peak.reward_chain_block.get_hash()
+                await time_out_assert(60, peak_new_peak_is_none, True, timelord_api)
+
+                await full_node.add_block(block_1)
+                await _validate_and_add_block(b1, block_1)
+                peak = timelord_peak_from_block(b1, block_1)
+                assert peak is not None
+                await timelord_api.new_peak_timelord(peak)
+                peak = await full_node.blockchain.get_full_peak()
+                assert peak == block_1
+                peak_tl = timelord_api.timelord.new_peak
+                assert peak_tl.reward_chain_block.get_hash() == peak.reward_chain_block.get_hash()
+
 
 async def get_rc_prev(blockchain: Blockchain, block: FullBlock) -> bytes32:
     if block.reward_chain_block.signage_point_index == 0:

chia/consensus/block_creation.py

@@ -54,7 +54,7 @@ def compute_block_cost(generator: BlockGenerator, constants: ConsensusConstants,
     else:
         run_block = run_block_generator
 
-    _, conds = run_block(
+    err, conds = run_block(
         bytes(generator.program),
         generator.generator_refs,
         constants.MAX_BLOCK_COST_CLVM,
@@ -63,6 +63,8 @@ def compute_block_cost(generator: BlockGenerator, constants: ConsensusConstants,
         None,
         constants,
     )
+    if conds is None:  # pragma: no cover
+        log.error(f"unexpected error while computing block cost: {err} height: {height} generator: {generator.program}")
     return uint64(0 if conds is None else conds.cost)
 
 

chia/full_node/full_node.py

@@ -2134,7 +2134,8 @@ class FullNode:
             )
             pre_validation_result = await future
             added: Optional[AddBlockResult] = None
-            pre_validation_time = time.monotonic() - validation_start
+            add_block_start = time.monotonic()
+            pre_validation_time = add_block_start - validation_start
             try:
                 if pre_validation_result.error is not None:
                     if Err(pre_validation_result.error) == Err.INVALID_PREV_BLOCK_HASH:
@@ -2153,6 +2154,7 @@ class FullNode:
                     (added, error_code, state_change_summary) = await self.blockchain.add_block(
                         block, pre_validation_result, ssi, fork_info
                     )
+                add_block_time = time.monotonic() - add_block_start
                 if added == AddBlockResult.ALREADY_HAVE_BLOCK:
                     return None
                 elif added == AddBlockResult.INVALID_BLOCK:
@@ -2181,7 +2183,7 @@ class FullNode:
                     self.log.info(
                         f"Received orphan block of height {block.height} rh {block.reward_chain_block.get_hash()}"
                     )
-                    post_process_time = 0
+                    post_process_time = 0.0
                 else:
                     # Should never reach here, all the cases are covered
                     raise RuntimeError(f"Invalid result from add_block {added}")
@@ -2197,7 +2199,11 @@ class FullNode:
 
         if ppp_result is not None:
             assert state_change_summary is not None
+            post_process_time2 = time.monotonic()
             await self.peak_post_processing_2(block, peer, state_change_summary, ppp_result)
+            post_process_time2 = time.monotonic() - post_process_time2
+        else:
+            post_process_time2 = 0.0
 
         percent_full_str = (
             (
@@ -2213,7 +2219,9 @@ class FullNode:
             f"Block validation: {validation_time:0.2f}s, "
             f"pre_validation: {pre_validation_time:0.2f}s, "
             f"CLVM: {pre_validation_result.timing / 1000.0:0.2f}s, "
+            f"add-block: {add_block_time:0.2f}s, "
             f"post-process: {post_process_time:0.2f}s, "
+            f"post-process2: {post_process_time2:0.2f}s, "
             f"cost: {block.transactions_info.cost if block.transactions_info is not None else 'None'}"
             f"{percent_full_str} header_hash: {header_hash.hex()} height: {block.height}",
         )
@@ -2847,10 +2855,16 @@ class FullNode:
 
         total_time = time.monotonic() - start_time
 
-        self.log.log(
-            logging.DEBUG if total_time < 0.5 else logging.WARNING,
-            f"Broadcasting added transaction {mempool_item.name} to {len(peer_ids)} peers took {total_time:.4f}s",
-        )
+        if len(peer_ids) == 0:
+            self.log.log(
+                logging.DEBUG if total_time < 0.5 else logging.WARNING,
+                f"Looking up hints for {len(conds.spends)} spends took {total_time:.4f}s",
+            )
+        else:
+            self.log.log(
+                logging.DEBUG if total_time < 0.5 else logging.WARNING,
+                f"Broadcasting added transaction {mempool_item.name} to {len(peer_ids)} peers took {total_time:.4f}s",
+            )
 
     async def broadcast_removed_tx(self, mempool_removals: list[MempoolRemoveInfo]) -> None:
         total_removals = sum(len(r.items) for r in mempool_removals)

chia/full_node/full_node_api.py

@@ -865,7 +865,7 @@ class FullNodeAPI:
                     try:
                         block = await self.full_node.mempool_manager.create_block_generator(curr_l_tb.header_hash)
                         if block is not None:
-                            block_generator, aggregate_signature, additions = block
+                            block_generator, aggregate_signature, additions, removals = block
                     except Exception as e:
                         self.log.error(f"Traceback: {traceback.format_exc()}")
                         self.full_node.log.error(f"Error making spend bundle {e} peak: {peak}")

chia/full_node/mempool.py

@@ -493,7 +493,7 @@ class Mempool:
         constants: ConsensusConstants,
         height: uint32,
         item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
-    ) -> Optional[tuple[BlockGenerator, G2Element, list[Coin]]]:
+    ) -> 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.
@@ -525,6 +525,7 @@ class Mempool:
             BlockGenerator(SerializedProgram.from_bytes(block_program), []),
             spend_bundle.aggregated_signature,
             additions,
+            removals,
         )
 
     async def create_bundle_from_mempool_items(

chia/full_node/mempool_manager.py

@@ -150,6 +150,143 @@ QUOTE_BYTES = 2
 QUOTE_EXECUTION_COST = 20
 
 
+def is_atom_canonical(clvm_buffer: bytes, offset: int) -> tuple[int, bool]:
+    b = clvm_buffer[offset]
+    if (b & 0b11000000) == 0b10000000:
+        # 6 bits length prefix
+        mask = 0b00111111
+        prefix_len = 0
+        min_value = 1
+    elif (b & 0b11100000) == 0b11000000:
+        # 5 + 8 bits length prefix
+        mask = 0b00011111
+        prefix_len = 1
+        min_value = 1 << 6
+    elif (b & 0b11110000) == 0b11100000:
+        # 4 + 8 + 8 bits length prefix
+        mask = 0b00001111
+        prefix_len = 2
+        min_value = 1 << (5 + 8)
+    elif (b & 0b11111000) == 0b11110000:
+        # 3 + 8 + 8 + 8 bits length prefix
+        mask = 0b00000111
+        prefix_len = 3
+        min_value = 1 << (4 + 8 + 8)
+    elif (b & 0b11111100) == 0b11111000:
+        # 2 + 8 + 8 + 8 + 8 bits length prefix
+        mask = 0b00000011
+        prefix_len = 4
+        min_value = 1 << (3 + 8 + 8 + 8)
+    elif (b & 0b11111110) == 0b11111100:
+        # 1 + 8 + 8 + 8 + 8 + 8 bits length prefix
+        mask = 0b00000001
+        prefix_len = 5
+        min_value = 1 << (2 + 8 + 8 + 8 + 8)
+
+    atom_len = b & mask
+    for i in range(prefix_len):
+        atom_len <<= 8
+        offset += 1
+        atom_len |= clvm_buffer[offset]
+
+    return 1 + prefix_len + atom_len, atom_len >= min_value
+
+
+def is_clvm_canonical(clvm_buffer: bytes) -> bool:
+    """
+    checks whether the CLVM serialization is all canonical representation.
+    atoms can be serialized in more than one way by using more bytes than
+    necessary to encode the length prefix. This functions ensures that all atoms are
+    encoded with the shortest representation. back-references are not allowed
+    and will make this function return false
+    """
+    assert clvm_buffer != b""
+
+    offset = 0
+    tokens_left = 1
+    while True:
+        b = clvm_buffer[offset]
+
+        # pair
+        if b == 0xFF:
+            tokens_left += 1
+            offset += 1
+            continue
+
+        # back references cannot be considered canonical, since they may be
+        # encoded in many different ways
+        if b == 0xFE:
+            return False
+
+        # small atom or NIL
+        if b <= 0x80:
+            tokens_left -= 1
+            offset += 1
+        else:
+            atom_len, canonical = is_atom_canonical(clvm_buffer, offset)
+            if not canonical:
+                return False
+            tokens_left -= 1
+            offset += atom_len
+
+        if tokens_left == 0:
+            break
+
+    # if there's garbage at the end, it's not canonical
+    return offset == len(clvm_buffer)
+
+
+def check_removals(
+    removals: dict[bytes32, CoinRecord],
+    bundle_coin_spends: dict[bytes32, BundleCoinSpend],
+    *,
+    get_items_by_coin_ids: Callable[[list[bytes32]], list[MempoolItem]],
+) -> tuple[Optional[Err], list[MempoolItem]]:
+    """
+    This function checks for double spends, unknown spends and conflicting transactions in mempool.
+    Returns Error (if any), the set of existing MempoolItems with conflicting spends (if any).
+    Note that additions are not checked for duplicates, because having duplicate additions requires also
+    having duplicate removals.
+    """
+    conflicts = set()
+    for coin_id, coin_bcs in bundle_coin_spends.items():
+        # 1. Checks if it's been spent already
+        if removals[coin_id].spent and not coin_bcs.eligible_for_fast_forward:
+            return Err.DOUBLE_SPEND, []
+
+        # 2. Checks if there's a mempool conflict
+        conflicting_items = get_items_by_coin_ids([coin_id])
+        for item in conflicting_items:
+            if item in conflicts:
+                continue
+            conflict_bcs = item.bundle_coin_spends[coin_id]
+            # if the spend we're adding to the mempool is not DEDUP nor FF, it's
+            # just a regular conflict
+            if not coin_bcs.eligible_for_fast_forward and not coin_bcs.eligible_for_dedup:
+                conflicts.add(item)
+
+            # if the spend we're adding is FF, but there's a conflicting spend
+            # that isn't FF, they can't be chained, so that's a conflict
+            elif coin_bcs.eligible_for_fast_forward and not conflict_bcs.eligible_for_fast_forward:
+                conflicts.add(item)
+
+            # if the spend we're adding is DEDUP, but there's a conflicting spend
+            # that isn't DEDUP, we cannot merge them, so that's a conflict
+            elif coin_bcs.eligible_for_dedup and not conflict_bcs.eligible_for_dedup:
+                conflicts.add(item)
+
+            # if the spend we're adding is DEDUP but the existing spend has a
+            # different solution, we cannot merge them, so that's a conflict
+            elif coin_bcs.eligible_for_dedup and bytes(coin_bcs.coin_spend.solution) != bytes(
+                conflict_bcs.coin_spend.solution
+            ):
+                conflicts.add(item)
+
+    if len(conflicts) > 0:
+        return Err.MEMPOOL_CONFLICT, list(conflicts)
+    return None, []
+
+
 class MempoolManager:
     pool: Executor
     constants: ConsensusConstants
@@ -247,9 +384,9 @@ class MempoolManager:
         self,
         last_tb_header_hash: bytes32,
         item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
-    ) -> Optional[tuple[BlockGenerator, G2Element, list[Coin]]]:
+    ) -> Optional[tuple[BlockGenerator, G2Element, list[Coin], list[Coin]]]:
         """
-        Returns a block generator program, the aggregate signature and all additions, for a new block
+        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
@@ -462,7 +599,6 @@ class MempoolManager:
         addition_amount: int = 0
         # Map of coin ID to eligibility information
         eligibility_and_additions: dict[bytes32, EligibilityAndAdditions] = {}
-        non_eligible_coin_ids: list[bytes32] = []
         for spend in conds.spends:
             coin_id = bytes32(spend.coin_id)
             removal_names.add(coin_id)
@@ -480,7 +616,6 @@ class MempoolManager:
                 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()
         bundle_coin_spends: dict[bytes32, BundleCoinSpend] = {}
         for coin_spend in new_spend.coin_spends:
             coin_id = coin_spend.coin.name()
@@ -489,6 +624,11 @@ class MempoolManager:
                 coin_id,
                 EligibilityAndAdditions(is_eligible_for_dedup=False, spend_additions=[], ff_puzzle_hash=None),
             )
+
+            supports_dedup = eligibility_info.is_eligible_for_dedup
+            if supports_dedup and not is_clvm_canonical(bytes(coin_spend.solution)):
+                return Err.INVALID_COIN_SOLUTION, 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:
@@ -500,13 +640,9 @@ class MempoolManager:
                 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):
-                non_eligible_coin_ids.append(coin_id)
             bundle_coin_spends[coin_id] = BundleCoinSpend(
                 coin_spend=coin_spend,
-                eligible_for_dedup=eligibility_info.is_eligible_for_dedup,
+                eligible_for_dedup=supports_dedup,
                 eligible_for_fast_forward=mark_as_fast_forward,
                 additions=eligibility_info.spend_additions,
                 latest_singleton_coin=latest_singleton_coin,
@@ -580,7 +716,9 @@ class MempoolManager:
 
         # Check removals against UnspentDB + DiffStore + Mempool + SpendBundle
         # Use this information later when constructing a block
-        fail_reason, conflicts = self.check_removals(non_eligible_coin_ids, removal_record_dict, fast_forward_coin_ids)
+        fail_reason, conflicts = check_removals(
+            removal_record_dict, bundle_coin_spends, get_items_by_coin_ids=self.mempool.get_items_by_coin_ids
+        )
 
         # If we have a mempool conflict, continue, since we still want to keep around the TX in the pending pool.
         if fail_reason is not None and fail_reason is not Err.MEMPOOL_CONFLICT:
@@ -650,33 +788,6 @@ class MempoolManager:
 
         return None, potential, [item.name for item in conflicts]
 
-    def check_removals(
-        self,
-        non_eligible_coin_ids: list[bytes32],
-        removals: dict[bytes32, CoinRecord],
-        fast_forward_coin_ids: set[bytes32],
-    ) -> tuple[Optional[Err], list[MempoolItem]]:
-        """
-        This function checks for double spends, unknown spends and conflicting transactions in mempool.
-        Returns Error (if any), the set of existing MempoolItems with conflicting spends (if any).
-        Note that additions are not checked for duplicates, because having duplicate additions requires also
-        having duplicate removals.
-        """
-        assert self.peak is not None
-        # 1. Checks if it's been spent already
-        for record in removals.values():
-            if record.spent:
-                # Only consider it a double spend if this is not a fast forward
-                if record.name not in fast_forward_coin_ids:
-                    return Err.DOUBLE_SPEND, []
-        # 2. Checks if there's a mempool conflict
-        # Only consider conflicts if the coin is not eligible for deduplication
-        conflicts = self.mempool.get_items_by_coin_ids(non_eligible_coin_ids)
-        if len(conflicts) > 0:
-            return Err.MEMPOOL_CONFLICT, conflicts
-        # 5. If coins can be spent return list of unspents as we see them in local storage
-        return None, []
-
     def get_spendbundle(self, bundle_hash: bytes32) -> Optional[SpendBundle]:
         """Returns a full SpendBundle if it's inside one the mempools"""
         item: Optional[MempoolItem] = self.mempool.get_item_by_id(bundle_hash)
@@ -721,6 +832,7 @@ class MempoolManager:
         assert new_peak.timestamp is not None
         self.fee_estimator.new_block_height(new_peak.height)
         included_items: list[MempoolItemInfo] = []
+        new_peak_start = time.monotonic()
 
         expired = self.mempool.new_tx_block(new_peak.height, new_peak.timestamp)
         mempool_item_removals: list[MempoolRemoveInfo] = [expired]
@@ -887,6 +999,8 @@ class MempoolManager:
             f"minimum fee rate (in FPC) to get in for 5M cost tx: {self.mempool.get_min_fee_rate(5000000)}"
         )
         self.mempool.fee_estimator.new_block(FeeBlockInfo(new_peak.height, included_items))
+        duration = time.monotonic() - new_peak_start
+        log.log(logging.WARNING if duration > 1 else logging.INFO, f"new_peak() took {duration:0.2f} seconds")
         return NewPeakInfo(txs_added, mempool_item_removals)
 
     def get_items_not_in_filter(self, mempool_filter: PyBIP158, limit: int = 100) -> list[SpendBundle]:

chia/harvester/harvester_api.py

@@ -88,7 +88,7 @@ class HarvesterAPI:
             f"sp_hash: {new_challenge.sp_hash}, signage_point_index: {new_challenge.signage_point_index}"
         )
 
-        start = time.time()
+        start = time.monotonic()
         assert len(new_challenge.challenge_hash) == 32
 
         loop = asyncio.get_running_loop()
@@ -254,11 +254,11 @@ class HarvesterAPI:
             self.harvester.log.debug(f"new_signage_point_harvester {passed} plots passed the plot filter")
 
         # Concurrently executes all lookups on disk, to take advantage of multiple disk parallelism
-        time_taken = time.time() - start
+        time_taken = time.monotonic() - start
         total_proofs_found = 0
         for filename_sublist_awaitable in asyncio.as_completed(awaitables):
             filename, sublist = await filename_sublist_awaitable
-            time_taken = time.time() - start
+            time_taken = time.monotonic() - start
             if time_taken > 8:
                 self.harvester.log.warning(
                     f"Looking up qualities on {filename} took: {time_taken}. This should be below 8 seconds"

chia/simulator/block_tools.py

@@ -19,7 +19,6 @@ from typing import Any, Callable, Optional
 import anyio
 from chia_puzzles_py.programs import CHIALISP_DESERIALISATION, ROM_BOOTSTRAP_GENERATOR
 from chia_rs import (
-    MEMPOOL_MODE,
     AugSchemeMPL,
     ConsensusConstants,
     G1Element,
@@ -75,7 +74,7 @@ from chia.simulator.wallet_tools import WalletTool
 from chia.ssl.create_ssl import create_all_ssl
 from chia.types.blockchain_format.classgroup import ClassgroupElement
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import INFINITE_COST, Program
+from chia.types.blockchain_format.program import DEFAULT_FLAGS, INFINITE_COST, Program
 from chia.types.blockchain_format.proof_of_space import (
     ProofOfSpace,
     calculate_pos_challenge,
@@ -1951,7 +1950,7 @@ def compute_cost_test(generator: BlockGenerator, constants: ConsensusConstants,
 
     if height >= constants.HARD_FORK_HEIGHT:
         blocks = generator.generator_refs
-        cost, result = generator.program._run(INFINITE_COST, MEMPOOL_MODE, [DESERIALIZE_MOD, blocks])
+        cost, result = generator.program._run(INFINITE_COST, DEFAULT_FLAGS, [DESERIALIZE_MOD, blocks])
         clvm_cost += cost
 
         for spend in result.first().as_iter():
@@ -1960,13 +1959,13 @@ def compute_cost_test(generator: BlockGenerator, constants: ConsensusConstants,
             puzzle = spend.at("rf")
             solution = spend.at("rrrf")
 
-            cost, result = puzzle._run(INFINITE_COST, MEMPOOL_MODE, solution)
+            cost, result = puzzle._run(INFINITE_COST, DEFAULT_FLAGS, solution)
             clvm_cost += cost
             condition_cost += conditions_cost(result)
 
     else:
         block_program_args = SerializedProgram.to([generator.generator_refs])
-        clvm_cost, result = GENERATOR_MOD._run(INFINITE_COST, MEMPOOL_MODE, [generator.program, block_program_args])
+        clvm_cost, result = GENERATOR_MOD._run(INFINITE_COST, DEFAULT_FLAGS, [generator.program, block_program_args])
 
         for res in result.first().as_iter():
             # each condition item is:

chia/timelord/timelord_api.py

@@ -53,6 +53,22 @@ class TimelordAPI:
                 self.timelord.state_changed("new_peak", {"height": new_peak.reward_chain_block.height})
                 return
 
+            # new peak has equal weight but lower iterations
+            if (
+                self.timelord.last_state.get_weight() == new_peak.reward_chain_block.weight
+                and self.timelord.last_state.peak.reward_chain_block.total_iters
+                > new_peak.reward_chain_block.total_iters
+            ):
+                log.info(
+                    "Not skipping peak, has equal weight but lower iterations,"
+                    f"current peak:{self.timelord.last_state.total_iters} new peak "
+                    f"{new_peak.reward_chain_block.total_iters}"
+                )
+                self.timelord.new_peak = new_peak
+                self.timelord.state_changed("new_peak", {"height": new_peak.reward_chain_block.height})
+                return
+
+            # new peak is heavier
             if self.timelord.last_state.get_weight() < new_peak.reward_chain_block.weight:
                 # if there is an unfinished block with less iterations, skip so we dont orphan it
                 if (
@@ -63,9 +79,9 @@ class TimelordAPI:
                     self.timelord.state_changed("skipping_peak", {"height": new_peak.reward_chain_block.height})
                     return
 
-                log.info("Not skipping peak, don't have. Maybe we are not the fastest timelord")
                 log.info(
-                    f"New peak: height: {new_peak.reward_chain_block.height} weight: "
+                    "Not skipping peak, don't have. Maybe we are not the fastest timelord "
+                    f"height: {new_peak.reward_chain_block.height} weight:"
                     f"{new_peak.reward_chain_block.weight} "
                 )
                 self.timelord.new_peak = new_peak
@@ -75,9 +91,9 @@ class TimelordAPI:
             if self.timelord.last_state.peak.reward_chain_block.get_hash() == new_peak.reward_chain_block.get_hash():
                 log.info("Skipping peak, already have.")
             else:
-                log.info("Skipping peak, block has equal or lower weight then our peak.")
-                log.debug(
-                    f"new peak height {new_peak.reward_chain_block.height} weight {new_peak.reward_chain_block.weight}"
+                log.info(
+                    f"Skipping peak height {new_peak.reward_chain_block.height} "
+                    f"weight {new_peak.reward_chain_block.weight}"
                 )
 
             self.timelord.state_changed("skipping_peak", {"height": new_peak.reward_chain_block.height})

chia/types/blockchain_format/program.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import io
 from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar
 
-from chia_rs import MEMPOOL_MODE, run_chia_program, tree_hash
+from chia_rs import ENABLE_KECCAK, MEMPOOL_MODE, run_chia_program, tree_hash
 from chia_rs.sized_bytes import bytes32
 from clvm.casts import int_from_bytes
 from clvm.CLVMObject import CLVMStorage
@@ -17,7 +17,7 @@ from chia.util.hash import std_hash
 
 INFINITE_COST = 11000000000
 
-DEFAULT_FLAGS = MEMPOOL_MODE
+DEFAULT_FLAGS = MEMPOOL_MODE | ENABLE_KECCAK
 
 T_CLVMStorage = TypeVar("T_CLVMStorage", bound=CLVMStorage)
 T_Program = TypeVar("T_Program", bound="Program")

{chia_blockchain-2.5.3rc1.dist-info → chia_blockchain-2.5.4rc1.dist-info}/METADATA

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

{chia_blockchain-2.5.3rc1.dist-info → chia_blockchain-2.5.4rc1.dist-info}/RECORD

@@ -118,11 +118,11 @@ chia/_tests/core/large_block.py,sha256=Ifi3lzBcwtBHDI7no3OTemhJMQZc5LlKC32QFNZwM
 chia/_tests/core/make_block_generator.py,sha256=4a4Q-lAJUYOjPlJTkMazOna-Rgp4VeNs8ju__OwebK4,2835
 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=KAOVmfUPk5QNY94iXYrm5JX3yRVqjnd-m_K1IiXfmUs,145380
+chia/_tests/core/mempool/test_mempool.py,sha256=_3ydxbt-LfIiju-4PW6qgvRSpvaHL7GqrxIIKeITEF4,145386
 chia/_tests/core/mempool/test_mempool_fee_estimator.py,sha256=lZZiTy-zOfrxuIWoQRnk_JLV9OJzuFqQwKwOgMwh3dQ,3714
 chia/_tests/core/mempool/test_mempool_fee_protocol.py,sha256=XUTKqs82IOiiZMGPTPSRhB4Zp8clbus5GlOoUtPtL6A,2165
 chia/_tests/core/mempool/test_mempool_item_queries.py,sha256=BESoQXx8XG2jSJiE12nslC3y_vPWrfCWPCrv4tGl3Js,7027
-chia/_tests/core/mempool/test_mempool_manager.py,sha256=e1WqJy270oY-FJ6-8pG_yNJbLOTZwTi9B4z4dN986Y8,114191
+chia/_tests/core/mempool/test_mempool_manager.py,sha256=KZCXRegcVxT6OUnXuOypJealnnLRZ6Dom4NxIWHH0lI,126728
 chia/_tests/core/mempool/test_mempool_performance.py,sha256=guLnMgE37swiQuyEXYPmtmMOXSa7o_fwBlXGHsOM4rU,2808
 chia/_tests/core/mempool/test_singleton_fast_forward.py,sha256=egp-7n5GCMlFebzwanQwPjOE24efhDBCvVrKEuEkQVU,38019
 chia/_tests/core/node_height.py,sha256=yfkEmmYCsAb3cIe1ZhtE9J2SFB9lG_49SgjxsITdrZk,917
@@ -237,7 +237,7 @@ chia/_tests/simulation/test_start_simulator.py,sha256=geCu_RMFuFlu1oaurcvubzwENY
 chia/_tests/testconfig.py,sha256=zLhG3F8aayQR34gLclQDmDfSsXu9GEaYpCuL4RteZpg,431
 chia/_tests/timelord/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/_tests/timelord/config.py,sha256=fTDhByaME5cEDbtyTKCWUf69F4kajs75aTQewZMjxak,69
-chia/_tests/timelord/test_new_peak.py,sha256=_zJtJoeo8PgT1D3tk3-EmRRV-s-fqwTvzgjoDaW4TLg,21961
+chia/_tests/timelord/test_new_peak.py,sha256=qvRlrJ6V6-DjSDmx_P6CUU6BByonHiWU97hJh_f17es,25238
 chia/_tests/timelord/test_timelord.py,sha256=5v8AbvHMws2AsoWW-K6e2dS3oy3j4PW4SN4VJnjASMM,298
 chia/_tests/tools/1315537.json,sha256=lT_jyWxuxw9B3Wc1Akr80l6y2RhVAtY8DW4zlfik-iE,19256
 chia/_tests/tools/1315544.json,sha256=8_dMCtu8nPPvR2KK5iqRd-Vit-VCb5dmYsjOtFWtIXA,19163
@@ -448,7 +448,7 @@ chia/cmds/wallet.py,sha256=KQiT86fmZrycAopFMUCD_-PWy0Hzpv0FHh9bE944clM,60888
 chia/cmds/wallet_funcs.py,sha256=A3LBfELVgdEKBFa1Z4ciVa4gRCVEvekKfCYPeJ9kbGQ,77227
 chia/consensus/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/consensus/block_body_validation.py,sha256=OQ2w7beihGMDyocYNcRBrvtoqk6sAG29E4BhWOaJZPk,24230
-chia/consensus/block_creation.py,sha256=8L33CT35nD2SZ3Sb2MS6UmuH3Xre-5uXs78SgGXLeU0,21822
+chia/consensus/block_creation.py,sha256=IZwnY6v3RkTdrUHXbBJXdVV1jFx9XsuI1i5LynqJJ38,21987
 chia/consensus/block_header_validation.py,sha256=bM9R4z6Z4OLmViD4yYh2yFn-aNbFEtThjWkYq93EzUc,51035
 chia/consensus/block_record.py,sha256=hL-UP7_Jnuebc4ano1daBMcZCB3mtcHfabOsso3hMRU,670
 chia/consensus/block_rewards.py,sha256=vmdHKqYudVnKvzq-ALAsSpy4RsTPLhdw-giJkwecdkM,2250
@@ -513,14 +513,14 @@ chia/full_node/fee_estimator_constants.py,sha256=GsQfI9Z7YzPWGEe6ghJeYvzbG87C86K
 chia/full_node/fee_estimator_interface.py,sha256=y6ICUB_69vkF2whcKFlN8lhmM3bR88yRTJb8e2ThG6M,1610
 chia/full_node/fee_history.py,sha256=hcLmy3HLuuATidOQ94wD7MAtzZU9PadKaKt8q3m8fVI,591
 chia/full_node/fee_tracker.py,sha256=vgJbP-zfaeL8tYToZxKm3JoBy5LWog6rD28FHycDBvQ,22626
-chia/full_node/full_node.py,sha256=E7oOM5bnmkQVZ3fhJBkhHK7Z-nxUNL7EAWrTxuVqfM0,166368
-chia/full_node/full_node_api.py,sha256=N-q1AygJGIb-CDvJyL_EN_VaHQ8sT5x7sk4PIqbRjbk,96830
+chia/full_node/full_node.py,sha256=fQwPCTVSmnYD36KR85QP6O4HOrdlhYlRtArMLScfXD8,167030
+chia/full_node/full_node_api.py,sha256=h9TbahfJ3P8tdSI76jfo683dV6Hwnkxj6C5Ckdo-Wgg,96840
 chia/full_node/full_node_store.py,sha256=1YGBgdS1Kim5FHbv-IMIegKkRRj8Hbqj55X1se7Du_8,47369
 chia/full_node/hint_management.py,sha256=8dVKguFPm-h32GEnMWxX2qyITo4WVO1YBKaPFKCeni0,2285
 chia/full_node/hint_store.py,sha256=0m6y0_f0rhGIKqfAmhFSGEeyM3LCN-dv-bR1OfIr4Uo,3666
-chia/full_node/mempool.py,sha256=qt9JWbIAE3Aql4LoRMRFEjyzuArckithY1yMdDyGMm8,28116
+chia/full_node/mempool.py,sha256=VK323fsHtnbn_zQMqE7dcBAf37_4K7X_wfYLmjvLK6c,28150
 chia/full_node/mempool_check_conditions.py,sha256=r_NXwXH5nLvO-YbhcZozrMIYOdHqyMRyDzBCVoIX1QA,5606
-chia/full_node/mempool_manager.py,sha256=IgW7eEwG2GbE2dZqvYVQQ1dWGnlUzilvwU2yqc2gvJI,46478
+chia/full_node/mempool_manager.py,sha256=YIqhNc-IuELYaODSuEeIGAgxuGGK1VepB98ehF-lBtM,50170
 chia/full_node/pending_tx_cache.py,sha256=jEL004L7r1n7ppeSdLVe6nsVNfYw0jU86DHmRYe1rH4,3657
 chia/full_node/signage_point.py,sha256=vtHQk3P0HLfOVpenGqmgqBoWnf_WCETHRplL_id9KyA,414
 chia/full_node/subscriptions.py,sha256=ItPMnGTgrfdzoeyC5TBbamrVWKvYnpabSLYUDBI5bmI,8706
@@ -530,7 +530,7 @@ chia/full_node/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 chia/full_node/weight_proof.py,sha256=oa-xC0Pzt-VZlFCvFYwZ5ZqlHiWzmUe1id8eEiVv6oE,71403
 chia/harvester/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/harvester/harvester.py,sha256=u2_trZnVRdsXGmuqfivA05aD2qjJjv2DNOyejLh8KAw,11825
-chia/harvester/harvester_api.py,sha256=e7-gDXy0-YhTRT2zdw-BDTBCII-sZs9EwxpE0BnZdZE,18711
+chia/harvester/harvester_api.py,sha256=-lzphxuk28fag82kpqLHmzhVrc441ForV6dDOja-zLo,18726
 chia/introducer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/introducer/introducer.py,sha256=InaxWLt8EprM7409cg2y03Qwm_641nLbnv6-sAjBp1Q,5535
 chia/introducer/introducer_api.py,sha256=VB1V0geTzVVi8UMdqUxqYt_fdFjUcATM8fjd-nMJnN8,2779
@@ -623,7 +623,7 @@ chia/server/upnp.py,sha256=o9zrYEBMFjnMq2-vUu7e5trPCP6JDPhn_5_jlQZX8f8,3746
 chia/server/ws_connection.py,sha256=6OM8xd0zb8RPtTqF0RRQ_UKLJjLHbRUov7BlszZsLvk,33801
 chia/simulator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/simulator/add_blocks_in_batches.py,sha256=YrQDNKkdrR9gaO0BDN_uSfycZWYQ2wZjw0FTxmmscmY,2460
-chia/simulator/block_tools.py,sha256=O7FK_1eAEsajZPbL9IOENcwwCd_JMQLKWkpxnJKRc-0,90747
+chia/simulator/block_tools.py,sha256=w3HawvkcKcNLYKetFZIXxLAZHlN0lBDa7yvMfcBDQeM,90747
 chia/simulator/full_node_simulator.py,sha256=W-n6DemccWw42yws2PBtpkAw6G5JQvtCJ9K_EnmK7fg,34758
 chia/simulator/keyring.py,sha256=RcumEHJy51zKeK0MZr7iqlugF8vPNRJvXDzXUgQ3y2A,5067
 chia/simulator/setup_services.py,sha256=16ivXZM2iUfo9-6F0l-E0JHuOP00b15vQ4F-NwurhyY,19255
@@ -653,7 +653,7 @@ chia/ssl/dst_root_ca.pem,sha256=E5peSk4PpQU3jHLF9wCTTOgzP05rG1CIhsSw6xT0vpk,1200
 chia/timelord/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/timelord/iters_from_block.py,sha256=cN9bSrcL5_4zO330o-MykOW3hqJpoALXeGa_YZqTku4,1721
 chia/timelord/timelord.py,sha256=ChQidb48mV72XsNn-olApar-ME4Ma99Dqgf3biD_hiY,59990
-chia/timelord/timelord_api.py,sha256=iHl4cMIZ6EMQuaIZKnEzYeg78xW6yxkHZh0m3w8VaeM,6743
+chia/timelord/timelord_api.py,sha256=14iD1CZt0ltXa5GNigo7KB0Ac8cD_z7HAlOhhm2srgA,7475
 chia/timelord/timelord_launcher.py,sha256=pgSYZd4-WxDJ7Mq92F7mUSuZfpGIzCpVJ4JdI9UTu04,6239
 chia/timelord/timelord_state.py,sha256=XLk5ITk1_sKG0SMq4X2J9ejLWSJNmvVAdKhWucrIt90,12022
 chia/timelord/types.py,sha256=FC5jywOnZvuWZmmM7Kr_O7UaZZLRSFI4WMZuzT-tZAg,354
@@ -663,7 +663,7 @@ chia/types/block_protocol.py,sha256=gXXp3tC8E-__sjC9ZkDzPxw085OifROeT7UuYBl3OcM,
 chia/types/blockchain_format/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/types/blockchain_format/classgroup.py,sha256=H4s9BO1lBroha6IAS96VUFPLKVy4dr8D8EXWhUFP0l8,107
 chia/types/blockchain_format/coin.py,sha256=n5uynipkU-N0c7vIJAxsbkO2V_zSA2R1LiiNkOqtl0Q,672
-chia/types/blockchain_format/program.py,sha256=fVXvH5F5hoH4X6XJ6FWUUMsCfUyXw1MP_v45HqTapWM,9528
+chia/types/blockchain_format/program.py,sha256=3JLAEzFg0EXj1vTuj4LqPXSzY1vnWbYwGAvQj2jMtjs,9559
 chia/types/blockchain_format/proof_of_space.py,sha256=EyRb5dvFY4Uf4uIn03mOhoVfHmt9r_KdMu3xurSBPp8,4946
 chia/types/blockchain_format/serialized_program.py,sha256=4pN6DiiLOx3CfXILguFbJCtDOkIKcRrTA8GWfuUU0pY,88
 chia/types/blockchain_format/slots.py,sha256=te3s0DCBR9XnFJMgzz1e3KahR2zX95noKj0bei_-67g,308
@@ -884,8 +884,8 @@ chia/wallet/wallet_transaction_store.py,sha256=PoSJLKuNNx0X8KVSQ92C5zGKIbBBDtPVW
 chia/wallet/wallet_user_store.py,sha256=rXiQpk5g8t1X0Chx0bValcQsHonjB1oQ_F_K16bphDA,4089
 chia/wallet/wallet_weight_proof_handler.py,sha256=d3UvjSP5X2gVIephBR9grutvYRC58Vr-HnV1ezJXrJ8,4914
 mozilla-ca/cacert.pem,sha256=UKYnfsaRE_AMX9RfCei5eks-MtqjXTqVqzATelU4bO8,233263
-chia_blockchain-2.5.3rc1.dist-info/LICENSE,sha256=0tuU-jTzeRDJJaxF2YCEpBwbywgpbrVSXq1i6fJq63U,11347
-chia_blockchain-2.5.3rc1.dist-info/METADATA,sha256=MR1qO_acIwnlHPayRZ2mg1mDAmhGWED9Gh7B05AMDbA,10673
-chia_blockchain-2.5.3rc1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-chia_blockchain-2.5.3rc1.dist-info/entry_points.txt,sha256=GL2-UvicPVdKz72IP4shnmV3XImfoD5pMzoURfoAYk4,742
-chia_blockchain-2.5.3rc1.dist-info/RECORD,,
+chia_blockchain-2.5.4rc1.dist-info/LICENSE,sha256=0tuU-jTzeRDJJaxF2YCEpBwbywgpbrVSXq1i6fJq63U,11347
+chia_blockchain-2.5.4rc1.dist-info/METADATA,sha256=qWftsOSNM2yhNHLtgjKRed9qbLgCvj2_nitjClANJBI,10673
+chia_blockchain-2.5.4rc1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+chia_blockchain-2.5.4rc1.dist-info/entry_points.txt,sha256=GL2-UvicPVdKz72IP4shnmV3XImfoD5pMzoURfoAYk4,742
+chia_blockchain-2.5.4rc1.dist-info/RECORD,,

{chia_blockchain-2.5.3rc1.dist-info → chia_blockchain-2.5.4rc1.dist-info}/WHEEL

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