chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7__py3-none-any.whl

chia/_tests/core/data_layer/test_data_store_schema.py

@@ -1,171 +1,17 @@
 from __future__ import annotations
 
 import sqlite3
-from typing import Any
 
 import pytest
 from chia_rs.sized_bytes import bytes32
 
-from chia._tests.core.data_layer.util import add_01234567_example, create_valid_node_values
-from chia.data_layer.data_layer_util import NodeType, Side, Status
+from chia._tests.core.data_layer.util import add_01234567_example
+from chia.data_layer.data_layer_util import Status
 from chia.data_layer.data_store import DataStore
 
 pytestmark = pytest.mark.data_layer
 
 
-@pytest.mark.anyio
-async def test_node_update_fails(data_store: DataStore, store_id: bytes32) -> None:
-    await add_01234567_example(data_store=data_store, store_id=store_id)
-    node = await data_store.get_node_by_key(key=b"\x04", store_id=store_id)
-
-    async with data_store.db_wrapper.writer() as writer:
-        with pytest.raises(sqlite3.IntegrityError, match=r"^updates not allowed to the node table$"):
-            await writer.execute(
-                "UPDATE node SET value = :value WHERE hash == :hash",
-                {
-                    "hash": node.hash,
-                    "value": node.value,
-                },
-            )
-
-
-@pytest.mark.parametrize(argnames="length", argvalues=sorted(set(range(50)) - {32}))
-@pytest.mark.anyio
-async def test_node_hash_must_be_32(
-    data_store: DataStore,
-    store_id: bytes32,
-    length: int,
-    valid_node_values: dict[str, Any],
-) -> None:
-    valid_node_values["hash"] = bytes([0] * length)
-
-    async with data_store.db_wrapper.writer() as writer:
-        with pytest.raises(sqlite3.IntegrityError, match=r"^CHECK constraint failed:"):
-            await writer.execute(
-                """
-                INSERT INTO node(hash, node_type, left, right, key, value)
-                VALUES(:hash, :node_type, :left, :right, :key, :value)
-                """,
-                valid_node_values,
-            )
-
-
-@pytest.mark.anyio
-async def test_node_hash_must_not_be_null(
-    data_store: DataStore,
-    store_id: bytes32,
-    valid_node_values: dict[str, Any],
-) -> None:
-    valid_node_values["hash"] = None
-
-    async with data_store.db_wrapper.writer() as writer:
-        with pytest.raises(sqlite3.IntegrityError, match=r"^NOT NULL constraint failed: node.hash$"):
-            await writer.execute(
-                """
-                INSERT INTO node(hash, node_type, left, right, key, value)
-                VALUES(:hash, :node_type, :left, :right, :key, :value)
-                """,
-                valid_node_values,
-            )
-
-
-@pytest.mark.anyio
-async def test_node_type_must_be_valid(
-    data_store: DataStore,
-    node_type: NodeType,
-    bad_node_type: int,
-    valid_node_values: dict[str, Any],
-) -> None:
-    valid_node_values["node_type"] = bad_node_type
-
-    async with data_store.db_wrapper.writer() as writer:
-        with pytest.raises(sqlite3.IntegrityError, match=r"^CHECK constraint failed:"):
-            await writer.execute(
-                """
-                INSERT INTO node(hash, node_type, left, right, key, value)
-                VALUES(:hash, :node_type, :left, :right, :key, :value)
-                """,
-                valid_node_values,
-            )
-
-
-@pytest.mark.parametrize(argnames="side", argvalues=Side)
-@pytest.mark.anyio
-async def test_node_internal_child_not_null(data_store: DataStore, store_id: bytes32, side: Side) -> None:
-    await add_01234567_example(data_store=data_store, store_id=store_id)
-    node_a = await data_store.get_node_by_key(key=b"\x02", store_id=store_id)
-    node_b = await data_store.get_node_by_key(key=b"\x04", store_id=store_id)
-
-    values = create_valid_node_values(node_type=NodeType.INTERNAL, left_hash=node_a.hash, right_hash=node_b.hash)
-
-    if side == Side.LEFT:
-        values["left"] = None
-    elif side == Side.RIGHT:
-        values["right"] = None
-
-    async with data_store.db_wrapper.writer() as writer:
-        with pytest.raises(sqlite3.IntegrityError, match=r"^CHECK constraint failed:"):
-            await writer.execute(
-                """
-                INSERT INTO node(hash, node_type, left, right, key, value)
-                VALUES(:hash, :node_type, :left, :right, :key, :value)
-                """,
-                values,
-            )
-
-
-@pytest.mark.parametrize(argnames="bad_child_hash", argvalues=[b"\x01" * 32, b"\0" * 31, b""])
-@pytest.mark.parametrize(argnames="side", argvalues=Side)
-@pytest.mark.anyio
-async def test_node_internal_must_be_valid_reference(
-    data_store: DataStore,
-    store_id: bytes32,
-    bad_child_hash: bytes,
-    side: Side,
-) -> None:
-    await add_01234567_example(data_store=data_store, store_id=store_id)
-    node_a = await data_store.get_node_by_key(key=b"\x02", store_id=store_id)
-    node_b = await data_store.get_node_by_key(key=b"\x04", store_id=store_id)
-
-    values = create_valid_node_values(node_type=NodeType.INTERNAL, left_hash=node_a.hash, right_hash=node_b.hash)
-
-    if side == Side.LEFT:
-        values["left"] = bad_child_hash
-    elif side == Side.RIGHT:
-        values["right"] = bad_child_hash
-    else:  # pragma: no cover
-        assert False
-
-    async with data_store.db_wrapper.writer() as writer:
-        with pytest.raises(sqlite3.IntegrityError, match=r"^FOREIGN KEY constraint failed$"):
-            await writer.execute(
-                """
-                INSERT INTO node(hash, node_type, left, right, key, value)
-                VALUES(:hash, :node_type, :left, :right, :key, :value)
-                """,
-                values,
-            )
-
-
-@pytest.mark.parametrize(argnames="key_or_value", argvalues=["key", "value"])
-@pytest.mark.anyio
-async def test_node_terminal_key_value_not_null(data_store: DataStore, store_id: bytes32, key_or_value: str) -> None:
-    await add_01234567_example(data_store=data_store, store_id=store_id)
-
-    values = create_valid_node_values(node_type=NodeType.TERMINAL)
-    values[key_or_value] = None
-
-    async with data_store.db_wrapper.writer() as writer:
-        with pytest.raises(sqlite3.IntegrityError, match=r"^CHECK constraint failed:"):
-            await writer.execute(
-                """
-                INSERT INTO node(hash, node_type, left, right, key, value)
-                VALUES(:hash, :node_type, :left, :right, :key, :value)
-                """,
-                values,
-            )
-
-
 @pytest.mark.parametrize(argnames="length", argvalues=sorted(set(range(50)) - {32}))
 @pytest.mark.anyio
 async def test_root_store_id_must_be_32(data_store: DataStore, store_id: bytes32, length: int) -> None:
@@ -250,21 +96,6 @@ async def test_root_generation_must_not_be_null(data_store: DataStore, store_id:
             )
 
 
-@pytest.mark.anyio
-async def test_root_node_hash_must_reference(data_store: DataStore) -> None:
-    values = {"tree_id": bytes32.zeros, "generation": 0, "node_hash": bytes32.zeros, "status": Status.PENDING}
-
-    async with data_store.db_wrapper.writer() as writer:
-        with pytest.raises(sqlite3.IntegrityError, match=r"^FOREIGN KEY constraint failed$"):
-            await writer.execute(
-                """
-                INSERT INTO root(tree_id, generation, node_hash, status)
-                VALUES(:tree_id, :generation, :node_hash, :status)
-                """,
-                values,
-            )
-
-
 @pytest.mark.parametrize(argnames="bad_status", argvalues=sorted(set(range(-20, 20)) - {*Status}))
 @pytest.mark.anyio
 async def test_root_status_must_be_valid(data_store: DataStore, store_id: bytes32, bad_status: int) -> None:
@@ -319,44 +150,6 @@ async def test_root_store_id_generation_must_be_unique(data_store: DataStore, st
             )
 
 
-@pytest.mark.parametrize(argnames="length", argvalues=sorted(set(range(50)) - {32}))
-@pytest.mark.anyio
-async def test_ancestors_ancestor_must_be_32(
-    data_store: DataStore,
-    store_id: bytes32,
-    length: int,
-) -> None:
-    async with data_store.db_wrapper.writer() as writer:
-        node_hash = await data_store._insert_terminal_node(key=b"\x00", value=b"\x01")
-        with pytest.raises(sqlite3.IntegrityError, match=r"^CHECK constraint failed:"):
-            await writer.execute(
-                """
-                INSERT INTO ancestors(hash, ancestor, tree_id, generation)
-                VALUES(:hash, :ancestor, :tree_id, :generation)
-                """,
-                {"hash": node_hash, "ancestor": bytes([0] * length), "tree_id": bytes32.zeros, "generation": 0},
-            )
-
-
-@pytest.mark.parametrize(argnames="length", argvalues=sorted(set(range(50)) - {32}))
-@pytest.mark.anyio
-async def test_ancestors_store_id_must_be_32(
-    data_store: DataStore,
-    store_id: bytes32,
-    length: int,
-) -> None:
-    async with data_store.db_wrapper.writer() as writer:
-        node_hash = await data_store._insert_terminal_node(key=b"\x00", value=b"\x01")
-        with pytest.raises(sqlite3.IntegrityError, match=r"^CHECK constraint failed:"):
-            await writer.execute(
-                """
-                INSERT INTO ancestors(hash, ancestor, tree_id, generation)
-                VALUES(:hash, :ancestor, :tree_id, :generation)
-                """,
-                {"hash": node_hash, "ancestor": bytes32.zeros, "tree_id": bytes([0] * length), "generation": 0},
-            )
-
-
 @pytest.mark.parametrize(argnames="length", argvalues=sorted(set(range(50)) - {32}))
 @pytest.mark.anyio
 async def test_subscriptions_store_id_must_be_32(

chia/_tests/core/full_node/ram_db.py

@@ -7,8 +7,8 @@ from pathlib import Path
 
 from chia_rs import ConsensusConstants
 
+from chia.consensus.block_height_map import BlockHeightMap
 from chia.consensus.blockchain import Blockchain
-from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.util.db_wrapper import DBWrapper2

chia/_tests/core/full_node/stores/test_block_store.py

@@ -18,10 +18,10 @@ from chia_rs.sized_ints import uint8, uint32, uint64
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
 from chia._tests.util.db_connection import DBConnection, PathDBConnection
 from chia.consensus.block_body_validation import ForkInfo
+from chia.consensus.block_height_map import BlockHeightMap
 from chia.consensus.blockchain import AddBlockResult, Blockchain
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.full_block_to_block_record import header_block_to_sub_block_record
-from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.full_block_utils import GeneratorBlockInfo
@@ -369,16 +369,10 @@ async def test_count_uncompactified_blocks(bt: BlockTools, tmp_dir: Path, db_ver
 async def test_replace_proof(bt: BlockTools, tmp_dir: Path, db_version: int, use_cache: bool) -> None:
     blocks = bt.get_consecutive_blocks(10)
 
-    def rand_bytes(num: int) -> bytes:
-        ret = bytearray(num)
-        for i in range(num):
-            ret[i] = random.getrandbits(8)
-        return bytes(ret)
-
     def rand_vdf_proof() -> VDFProof:
         return VDFProof(
             uint8(1),  # witness_type
-            rand_bytes(32),  # witness
+            random.randbytes(32),  # witness
             bool(random.randint(0, 1)),  # normalized_to_identity
         )
 
@@ -424,8 +418,8 @@ async def test_get_generator(bt: BlockTools, db_version: int, use_cache: bool) -
         store = await BlockStore.create(db_wrapper, use_cache=use_cache)
 
         new_blocks = []
-        for i, block in enumerate(blocks):
-            block = block.replace(transactions_generator=generator(i))
+        for i, original_block in enumerate(blocks):
+            block = original_block.replace(transactions_generator=generator(i))
             block_record = header_block_to_sub_block_record(
                 DEFAULT_CONSTANTS, uint64(0), block, uint64(0), False, uint8(0), uint32(max(0, block.height - 1)), None
             )

chia/_tests/core/full_node/stores/test_coin_store.py

@@ -16,10 +16,10 @@ from chia._tests.util.coin_store import add_coin_records_to_db
 from chia._tests.util.db_connection import DBConnection
 from chia._tests.util.misc import Marks, datacases
 from chia.consensus.block_body_validation import ForkInfo
+from chia.consensus.block_height_map import BlockHeightMap
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.blockchain import AddBlockResult, Blockchain
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
-from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.hint_store import HintStore

chia/_tests/core/full_node/test_address_manager.py

@@ -560,7 +560,7 @@ class TestPeerManager:
     # use tmp_path pytest fixture to create a temporary directory
     async def test_serialization(self, tmp_path: Path):
         addrman = AddressManagerTest()
-        now = int(math.floor(time.time()))
+        now = math.floor(time.time())
         t_peer1 = TimestampedPeerInfo("250.7.1.1", uint16(8333), uint64(now - 10000))
         t_peer2 = TimestampedPeerInfo("1050:0000:0000:0000:0005:0600:300c:326b", uint16(9999), uint64(now - 20000))
         t_peer3 = TimestampedPeerInfo("250.7.3.3", uint16(9999), uint64(now - 30000))
@@ -587,7 +587,7 @@ class TestPeerManager:
     @pytest.mark.anyio
     async def test_bad_ip_encoding(self, tmp_path: Path):
         addrman = AddressManagerTest()
-        now = int(math.floor(time.time()))
+        now = math.floor(time.time())
         t_peer1 = TimestampedPeerInfo("250.7.1.1", uint16(8333), uint64(now - 10000))
         t_peer2 = TimestampedPeerInfo("1050:0000:0000:0000:0005:0600:300c:326b", uint16(9999), uint64(now - 20000))
         t_peer3 = TimestampedPeerInfo("250.7.3.3", uint16(9999), uint64(now - 30000))
@@ -725,7 +725,7 @@ class TestPeerManager:
 
         # create a file with the old serialization, then migrate to new serialization
         addrman = AddressManagerTest()
-        now = int(math.floor(time.time()))
+        now = math.floor(time.time())
         t_peer1 = TimestampedPeerInfo("250.7.1.1", uint16(8333), uint64(now - 10000))
         t_peer2 = TimestampedPeerInfo("1050:0000:0000:0000:0005:0600:300c:326b", uint16(9999), uint64(now - 20000))
         t_peer3 = TimestampedPeerInfo("250.7.3.3", uint16(9999), uint64(now - 30000))

chia/_tests/core/full_node/test_block_height_map.py

@@ -11,7 +11,7 @@ from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32
 
 from chia._tests.util.db_connection import DBConnection
-from chia.full_node.block_height_map import BlockHeightMap, SesCache
+from chia.consensus.block_height_map import BlockHeightMap, SesCache
 from chia.util.db_wrapper import DBWrapper2
 from chia.util.files import write_file_async
 

chia/_tests/core/full_node/test_full_node.py

@@ -112,11 +112,11 @@ from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
 def test_pre_validation_result() -> None:
-    conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, True, 0, 0)
+    conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, True, 0, 0, 0, 0, 0)
     results = PreValidationResult(None, uint64(1), conds, uint32(0))
     assert results.validated_signature is True
 
-    conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, False, 0, 0)
+    conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, False, 0, 0, 0, 0, 0)
     results = PreValidationResult(None, uint64(1), conds, uint32(0))
     assert results.validated_signature is False
 
@@ -548,7 +548,7 @@ async def test_request_peers(
     async def have_msgs(full_node_peers: FullNodePeers) -> bool:
         assert full_node_peers.address_manager is not None
         await full_node_peers.address_manager.add_to_new_table(
-            [TimestampedPeerInfo("127.0.0.1", uint16(1000), uint64(int(time.time()) - 1000))],
+            [TimestampedPeerInfo("127.0.0.1", uint16(1000), uint64(time.time() - 1000))],
             None,
         )
         assert server_2._port is not None
@@ -919,6 +919,10 @@ async def test_new_peak(
 
 
 @pytest.mark.anyio
+@pytest.mark.limit_consensus_modes(
+    allowed=[ConsensusMode.HARD_FORK_2_0, ConsensusMode.HARD_FORK_3_0],
+    reason="We can no longer (reliably) farm blocks from before the hard fork",
+)
 async def test_new_transaction_and_mempool(
     wallet_nodes: tuple[
         FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
@@ -946,8 +950,10 @@ async def test_new_transaction_and_mempool(
 
     # Makes a bunch of coins
     conditions_dict: dict[ConditionOpcode, list[ConditionWithArgs]] = {ConditionOpcode.CREATE_COIN: []}
-    # This should fit in one transaction
-    for _ in range(100):
+    # This should fit in one transaction. The test constants have a max block cost of 400,000,000
+    # and the default max *transaction* cost is half that, so 200,000,000. CREATE_COIN has a cost of
+    # 1,800,000, we create 80 coins
+    for _ in range(80):
         receiver_puzzlehash = wallet_receiver.get_new_puzzlehash()
         puzzle_hashes.append(receiver_puzzlehash)
         output = ConditionWithArgs(ConditionOpcode.CREATE_COIN, [receiver_puzzlehash, int_to_bytes(10000000000)])
@@ -1046,8 +1052,8 @@ async def test_new_transaction_and_mempool(
     # these numbers reflect the capacity of the mempool. In these
     # tests MEMPOOL_BLOCK_BUFFER is 1. The other factors are COST_PER_BYTE
     # and MAX_BLOCK_COST_CLVM
-    assert included_tx == 23
-    assert not_included_tx == 10
+    assert included_tx == 20
+    assert not_included_tx == 7
     assert seen_bigger_transaction_has_high_fee
 
     # Mempool is full
@@ -1882,7 +1888,9 @@ async def test_new_signage_point_caching(
 ) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
     blocks = await full_node_1.get_all_full_blocks()
-
+    assert full_node_1.full_node.full_node_store.get_signage_point_by_index_and_cc_output(
+        bytes32.zeros, full_node_1.full_node.constants.GENESIS_CHALLENGE, uint8(0)
+    ) == SignagePoint(None, None, None, None)
     peer = await connect_and_get_peer(server_1, server_2, self_hostname)
     blocks = bt.get_consecutive_blocks(3, block_list_input=blocks, skip_slots=2)
     await full_node_1.full_node.add_block(blocks[-3])
@@ -1951,10 +1959,6 @@ async def test_new_signage_point_caching(
         is not None
     )
 
-    assert full_node_1.full_node.full_node_store.get_signage_point_by_index_and_cc_output(
-        full_node_1.full_node.constants.GENESIS_CHALLENGE, bytes32.zeros, uint8(0)
-    ) == SignagePoint(None, None, None, None)
-
 
 @pytest.mark.anyio
 async def test_slot_catch_up_genesis(
@@ -2678,16 +2682,15 @@ async def test_long_reorg_nodes(
             blocks = default_10000_blocks[: 1600 - chain_length]
             reorg_blocks = test_long_reorg_blocks_light[: 1600 - chain_length]
             reorg_height = 2000
-    else:
-        if fork_point == 1500:
-            blocks = default_10000_blocks[: 1900 - chain_length]
-            reorg_blocks = test_long_reorg_1500_blocks[: 1900 - chain_length]
-            reorg_height = 2300
-        else:  # pragma: no cover
-            pytest.skip("We rely on the light-blocks test for a 0 forkpoint")
-            blocks = default_10000_blocks[: 1100 - chain_length]
-            # reorg_blocks = test_long_reorg_blocks[: 1100 - chain_length]
-            reorg_height = 1600
+    elif fork_point == 1500:
+        blocks = default_10000_blocks[: 1900 - chain_length]
+        reorg_blocks = test_long_reorg_1500_blocks[: 1900 - chain_length]
+        reorg_height = 2300
+    else:  # pragma: no cover
+        pytest.skip("We rely on the light-blocks test for a 0 forkpoint")
+        blocks = default_10000_blocks[: 1100 - chain_length]
+        # reorg_blocks = test_long_reorg_blocks[: 1100 - chain_length]
+        reorg_height = 1600
 
     # this is a pre-requisite for a reorg to happen
     assert default_10000_blocks[reorg_height].weight > reorg_blocks[-1].weight
@@ -3163,15 +3166,14 @@ async def declare_pos_unfinished_block(
         challenge_chain_sp = block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
     if block.reward_chain_block.reward_chain_sp_vdf is not None:
         reward_chain_sp = block.reward_chain_block.reward_chain_sp_vdf.output.get_hash()
+    elif len(block.finished_sub_slots) > 0:
+        reward_chain_sp = block.finished_sub_slots[-1].reward_chain.get_hash()
     else:
-        if len(block.finished_sub_slots) > 0:
-            reward_chain_sp = block.finished_sub_slots[-1].reward_chain.get_hash()
-        else:
-            curr = blockchain.block_record(block.prev_header_hash)
-            while not curr.first_in_sub_slot:
-                curr = blockchain.block_record(curr.prev_hash)
-            assert curr.finished_reward_slot_hashes is not None
-            reward_chain_sp = curr.finished_reward_slot_hashes[-1]
+        curr = blockchain.block_record(block.prev_header_hash)
+        while not curr.first_in_sub_slot:
+            curr = blockchain.block_record(curr.prev_hash)
+        assert curr.finished_reward_slot_hashes is not None
+        reward_chain_sp = curr.finished_reward_slot_hashes[-1]
     farmer_reward_address = block.foliage.foliage_block_data.farmer_reward_puzzle_hash
     pool_target = block.foliage.foliage_block_data.pool_target
     pool_target_signature = block.foliage.foliage_block_data.pool_signature
@@ -3296,3 +3298,62 @@ def compare_unfinished_blocks(block1: UnfinishedBlock, block2: UnfinishedBlock)
     # Final assertion to check the entire block
     assert block1 == block2, "The entire block objects are not identical"
     return True
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "condition, error",
+    [
+        (ConditionOpcode.ASSERT_HEIGHT_RELATIVE, "ASSERT_HEIGHT_RELATIVE_FAILED"),
+        (ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, "ASSERT_HEIGHT_ABSOLUTE_FAILED"),
+    ],
+)
+async def test_pending_tx_cache_retry_on_new_peak(
+    condition: ConditionOpcode, error: str, blockchain_constants: ConsensusConstants, caplog: pytest.LogCaptureFixture
+) -> None:
+    """
+    Covers PendingTXCache items that are placed there due to unmet relative or
+    absolute height conditions, to make sure those items get retried at peak
+    post processing when those conditions are met.
+    """
+    async with setup_simulators_and_wallets(1, 0, blockchain_constants) as new:
+        full_node_api = new.simulators[0].peer_api
+        bt = new.bt
+        wallet = WalletTool(test_constants)
+        ph = wallet.get_new_puzzlehash()
+        blocks = bt.get_consecutive_blocks(
+            3, guarantee_transaction_block=True, farmer_reward_puzzle_hash=ph, pool_reward_puzzle_hash=ph
+        )
+        for block in blocks:
+            await full_node_api.full_node.add_block(block)
+        peak = full_node_api.full_node.blockchain.get_peak()
+        assert peak is not None
+        current_height = peak.height
+        # Create a transaction with a height condition that makes it pending
+        coin = blocks[-1].get_included_reward_coins()[0]
+        if condition == ConditionOpcode.ASSERT_HEIGHT_RELATIVE:
+            condition_height = 1
+        else:
+            condition_height = current_height + 1
+        condition_dic = {condition: [ConditionWithArgs(condition, [int_to_bytes(condition_height)])]}
+        sb = wallet.generate_signed_transaction(uint64(42), ph, coin, condition_dic)
+        sb_name = sb.name()
+        # Send the transaction
+        res = await full_node_api.send_transaction(SendTransaction(sb))
+        assert res is not None
+        assert ProtocolMessageTypes(res.type) == ProtocolMessageTypes.transaction_ack
+        transaction_ack = TransactionAck.from_bytes(res.data)
+        assert transaction_ack.status == MempoolInclusionStatus.PENDING.value
+        assert transaction_ack.error == error
+        # Make sure it ends up in the pending cache, not the mempool
+        assert full_node_api.full_node.mempool_manager.get_mempool_item(sb_name, include_pending=False) is None
+        assert full_node_api.full_node.mempool_manager.get_mempool_item(sb_name, include_pending=True) is not None
+        # Advance peak to meet the asserted height condition
+        with caplog.at_level(logging.DEBUG):
+            blocks = bt.get_consecutive_blocks(2, block_list_input=blocks, guarantee_transaction_block=True)
+            for block in blocks:
+                await full_node_api.full_node.add_block(block)
+        # This should trigger peak post processing with the added transaction
+        assert f"Added transaction to mempool: {sb_name}\n" in caplog.text
+        # Make sure the transaction was retried and got added to the mempool
+        assert full_node_api.full_node.mempool_manager.get_mempool_item(sb_name, include_pending=False) is not None

chia/_tests/core/full_node/test_generator_tools.py

@@ -2,12 +2,15 @@ from __future__ import annotations
 
 import pytest
 from chia_rs import Program as SerializedProgram
-from chia_rs import SpendBundleConditions, SpendConditions
-from chia_rs.sized_bytes import bytes32
+from chia_rs import (
+    SpendBundleConditions,
+    SpendConditions,
+    get_spends_for_trusted_block,
+    get_spends_for_trusted_block_with_conditions,
+)
 from chia_rs.sized_ints import uint32, uint64
 
 from chia.consensus.generator_tools import tx_removals_and_additions
-from chia.full_node.mempool_check_conditions import get_spends_for_block, get_spends_for_block_with_conditions
 from chia.simulator.block_tools import test_constants
 from chia.types.blockchain_format.coin import Coin
 from chia.types.generator_types import BlockGenerator
@@ -43,6 +46,7 @@ spends: list[SpendConditions] = [
         0,
         execution_cost=0,
         condition_cost=0,
+        fingerprint=b"",
     ),
     SpendConditions(
         coin_ids[1],
@@ -70,19 +74,20 @@ spends: list[SpendConditions] = [
         0,
         execution_cost=0,
         condition_cost=0,
+        fingerprint=b"",
     ),
 ]
 
 
 def test_tx_removals_and_additions() -> None:
     conditions = SpendBundleConditions(
-        spends, uint64(0), uint32(0), uint64(0), None, None, [], uint64(0), 0, 0, False, 0, 0
+        spends, uint64(0), uint32(0), uint64(0), None, None, [], uint64(0), 0, 0, False, 0, 0, 0, 0, 0
     )
     expected_rems = [coin_ids[0], coin_ids[1]]
     expected_additions = []
     for spend in spends:
         for puzzle_hash, am, _ in spend.create_coin:
-            expected_additions.append(Coin(bytes32(spend.coin_id), bytes32(puzzle_hash), uint64(am)))
+            expected_additions.append(Coin(spend.coin_id, puzzle_hash, uint64(am)))
     rems, adds = tx_removals_and_additions(conditions)
     assert rems == expected_rems
     assert adds == expected_additions
@@ -102,12 +107,14 @@ TEST_GENERATOR = BlockGenerator(
 
 
 def test_get_spends_for_block(caplog: pytest.LogCaptureFixture) -> None:
-    conditions = get_spends_for_block(TEST_GENERATOR, 100, test_constants)
-    assert conditions == []
-    assert "get_spends_for_block() encountered a puzzle we couldn't serialize: " in caplog.text
+    conditions = get_spends_for_trusted_block(
+        test_constants, TEST_GENERATOR.program, TEST_GENERATOR.generator_refs, 100
+    )
+    assert conditions["block_spends"] == []
 
 
 def test_get_spends_for_block_with_conditions(caplog: pytest.LogCaptureFixture) -> None:
-    conditions = get_spends_for_block_with_conditions(TEST_GENERATOR, 100, test_constants)
+    conditions = get_spends_for_trusted_block_with_conditions(
+        test_constants, TEST_GENERATOR.program, TEST_GENERATOR.generator_refs, 100
+    )
     assert conditions == []
-    assert "get_spends_for_block_with_conditions() encountered a puzzle we couldn't serialize: " in caplog.text