chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5rc1__py3-none-any.whl

chia/_tests/core/full_node/test_generator_tools.py

@@ -1,11 +1,16 @@
 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.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.spend_bundle_conditions import SpendBundleConditions, SpendConditions
-from chia.util.generator_tools import tx_removals_and_additions
+from chia.types.generator_types import BlockGenerator
 from chia.util.hash import std_hash
 
 coin_ids = [std_hash(i.to_bytes(4, "big")) for i in range(10)]
@@ -36,6 +41,8 @@ spends: list[SpendConditions] = [
         [],
         [],
         0,
+        execution_cost=0,
+        condition_cost=0,
     ),
     SpendConditions(
         coin_ids[1],
@@ -61,6 +68,8 @@ spends: list[SpendConditions] = [
         [],
         [],
         0,
+        execution_cost=0,
+        condition_cost=0,
     ),
 ]
 
@@ -81,3 +90,24 @@ def test_tx_removals_and_additions() -> None:
 
 def test_empty_conditions() -> None:
     assert tx_removals_and_additions(None) == ([], [])
+
+
+# this is a malicious generator which should fail
+TEST_GENERATOR = BlockGenerator(
+    SerializedProgram.fromhex(
+        "ff02ffff01ff02ffff01ff04ffff04ffff04ffff01a00101010101010101010101010101010101010101010101010101010101010101ffff04ffff04ffff0101ffff02ff02ffff04ff02ffff04ff05ffff04ff0bffff04ff17ff80808080808080ffff01ff7bffff80ffff018080808080ff8080ff8080ffff04ffff01ff02ffff03ff17ffff01ff04ff05ffff04ff0bffff02ff02ffff04ff02ffff04ff05ffff04ff0bffff04ffff11ff17ffff010180ff8080808080808080ff8080ff0180ff018080ffff04ffff01ff42ff24ff8568656c6c6fffa0010101010101010101010101010101010101010101010101010101010101010180ffff04ffff01ff43ff24ff8568656c6c6fffa0010101010101010101010101010101010101010101010101010101010101010180ffff04ffff01830f4240ff0180808080"
+    ),
+    [],
+)
+
+
+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
+
+
+def test_get_spends_for_block_with_conditions(caplog: pytest.LogCaptureFixture) -> None:
+    conditions = get_spends_for_block_with_conditions(TEST_GENERATOR, 100, test_constants)
+    assert conditions == []
+    assert "get_spends_for_block_with_conditions() encountered a puzzle we couldn't serialize: " in caplog.text

chia/_tests/core/full_node/test_hint_management.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 from typing import Optional
 
 import pytest
+from chia_rs import BlockRecord
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain import Blockchain, StateChangeSummary
 from chia.full_node.hint_management import get_hints_and_subscription_coin_ids
 from chia.simulator.block_tools import BlockTools

chia/_tests/core/full_node/test_node_load.py

@@ -8,27 +8,26 @@ from chia._tests.util.time_out_assert import time_out_assert
 from chia.types.peer_info import PeerInfo
 
 
-class TestNodeLoad:
-    @pytest.mark.anyio
-    async def test_blocks_load(self, two_nodes, self_hostname, benchmark_runner: BenchmarkRunner):
-        num_blocks = 50
-        full_node_1, full_node_2, server_1, server_2, bt = two_nodes
-        blocks = bt.get_consecutive_blocks(num_blocks)
-        await full_node_1.full_node.add_block(blocks[0])
-        await time_out_assert(10, node_height_at_least, True, full_node_1, 0)
-        await server_2.start_client(
-            PeerInfo(self_hostname, server_1.get_port()), on_connect=full_node_2.full_node.on_connect
-        )
+@pytest.mark.anyio
+async def test_blocks_load(two_nodes, self_hostname, benchmark_runner: BenchmarkRunner):
+    num_blocks = 50
+    full_node_1, full_node_2, server_1, server_2, bt = two_nodes
+    blocks = bt.get_consecutive_blocks(num_blocks)
+    await full_node_1.full_node.add_block(blocks[0])
+    await time_out_assert(10, node_height_at_least, True, full_node_1, 0)
+    await server_2.start_client(
+        PeerInfo(self_hostname, server_1.get_port()), on_connect=full_node_2.full_node.on_connect
+    )
 
-        async def num_connections():
-            return len(server_2.get_connections())
+    async def num_connections():
+        return len(server_2.get_connections())
 
-        await time_out_assert(10, num_connections, 1)
-        await time_out_assert(10, node_height_at_least, True, full_node_2, 0)
+    await time_out_assert(10, num_connections, 1)
+    await time_out_assert(10, node_height_at_least, True, full_node_2, 0)
 
-        with benchmark_runner.assert_runtime(seconds=100) as runtime_results_future:
-            for i in range(1, num_blocks):
-                await full_node_1.full_node.add_block(blocks[i])
-                await full_node_2.full_node.add_block(blocks[i])
-        runtime_results = runtime_results_future.result(timeout=0)
-        print(f"Time taken to process {num_blocks} is {runtime_results.duration}")
+    with benchmark_runner.assert_runtime(seconds=100) as runtime_results_future:
+        for i in range(1, num_blocks):
+            await full_node_1.full_node.add_block(blocks[i])
+            await full_node_2.full_node.add_block(blocks[i])
+    runtime_results = runtime_results_future.result(timeout=0)
+    print(f"Time taken to process {num_blocks} is {runtime_results.duration}")

chia/_tests/core/full_node/test_performance.py

@@ -4,20 +4,19 @@ import logging
 import random
 
 import pytest
+from chia_rs import BlockRecord, UnfinishedBlock
 from chia_rs.sized_ints import uint64
-from clvm.casts import int_to_bytes
 
 from chia._tests.connection_utils import add_dummy_connection
 from chia._tests.core.full_node.stores.test_coin_store import get_future_reward_coins
 from chia._tests.core.node_height import node_height_at_least
 from chia._tests.util.misc import BenchmarkRunner
 from chia._tests.util.time_out_assert import time_out_assert
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.pot_iterations import is_overflow_block
 from chia.protocols import full_node_protocol as fnp
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
-from chia.types.unfinished_block import UnfinishedBlock
+from chia.util.casts import int_to_bytes
 
 log = logging.getLogger(__name__)
 
@@ -123,7 +122,7 @@ class TestPerformance:
         curr: BlockRecord = peak
         while not curr.is_transaction_block:
             curr = full_node_1.full_node.blockchain.block_record(curr.prev_hash)
-        mempool_bundle = await full_node_1.full_node.mempool_manager.create_bundle_from_mempool(curr.header_hash)
+        mempool_bundle = full_node_1.full_node.mempool_manager.create_bundle_from_mempool(curr.header_hash)
         if mempool_bundle is None:
             spend_bundle = None
         else:

chia/_tests/core/full_node/test_prev_tx_block.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from chia_rs.sized_ints import uint32
+
+from chia.consensus.generator_tools import get_block_header
+from chia.consensus.get_block_challenge import prev_tx_block
+from chia.simulator.block_tools import BlockTools, load_block_list
+from chia.util.block_cache import BlockCache
+
+
+def test_prev_tx_block_none() -> None:
+    # If prev_b is None, should return 0
+    assert prev_tx_block(BlockCache({}), None) == uint32(0)
+
+
+def test_prev_tx_block_blockrecord_tx(bt: BlockTools) -> None:
+    # If prev_b is BlockRecord and prev_transaction_block_hash is not None, return its height
+    block_list = bt.get_consecutive_blocks(
+        10,
+        block_list_input=[],
+        guarantee_transaction_block=True,
+    )
+    _, _, blocks = load_block_list(block_list, bt.constants)
+    assert prev_tx_block(BlockCache(blocks), block_list[-1]) == uint32(9)
+    assert prev_tx_block(BlockCache(blocks), blocks[block_list[-1].header_hash]) == uint32(9)
+    assert prev_tx_block(BlockCache(blocks), get_block_header(block_list[-1])) == uint32(9)
+
+
+def test_prev_tx_block_blockrecord_not_tx(bt: BlockTools) -> None:
+    # If prev_b is BlockRecord and prev_transaction_block_hash is not None, return its height
+    block_list = bt.get_consecutive_blocks(
+        8,
+        block_list_input=[],
+        guarantee_transaction_block=True,
+    )
+    block_list = bt.get_consecutive_blocks(
+        2,
+        block_list_input=block_list,
+    )
+    _, _, blocks = load_block_list(block_list, bt.constants)
+    assert prev_tx_block(BlockCache(blocks), block_list[-1]) == uint32(7)
+    assert prev_tx_block(BlockCache(blocks), blocks[block_list[-1].header_hash]) == uint32(7)
+    assert prev_tx_block(BlockCache(blocks), get_block_header(block_list[-1])) == uint32(7)

chia/_tests/core/full_node/test_subscriptions.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from chia_rs import AugSchemeMPL, Coin, CoinSpend, G2Element, Program
+from chia_rs import AugSchemeMPL, Coin, CoinSpend, G2Element, Program, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
@@ -9,7 +9,6 @@ from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bundle_tools import simple_solution_generator
 from chia.full_node.subscriptions import PeerSubscriptions, peers_for_spend_bundle
 from chia.types.blockchain_format.program import INFINITE_COST
-from chia.types.spend_bundle import SpendBundle
 
 IDENTITY_PUZZLE = Program.to(1)
 IDENTITY_PUZZLE_HASH = IDENTITY_PUZZLE.get_tree_hash()

chia/_tests/core/full_node/test_transactions.py

@@ -5,11 +5,11 @@ import random
 from typing import Optional
 
 import pytest
+from chia_rs import BlockRecord
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
 from chia._tests.util.time_out_assert import time_out_assert
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
@@ -25,7 +25,8 @@ async def test_wallet_coinbase(simulator_and_wallet, self_hostname):
     full_node_server = full_node_api.server
     wallet_node, server_2 = wallets[0]
     wallet = wallet_node.wallet_state_manager.main_wallet
-    ph = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
 
     await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
     for i in range(num_blocks):
@@ -54,8 +55,10 @@ async def test_tx_propagation(three_nodes_two_wallets, self_hostname, seeded_ran
     full_node_api_2 = full_nodes[2]
     server_2 = full_node_api_2.server
 
-    ph = await wallet_0.wallet_state_manager.main_wallet.get_new_puzzlehash()
-    ph1 = await wallet_1.wallet_state_manager.main_wallet.get_new_puzzlehash()
+    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet_0.wallet_state_manager)
+    async with wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph1 = await action_scope.get_puzzle_hash(wallet_1.wallet_state_manager)
 
     #
     # wallet0 <-> sever0 <-> server1 <-> server2 <-> wallet1
@@ -134,7 +137,8 @@ async def test_mempool_tx_sync(three_nodes_two_wallets, self_hostname, seeded_ra
     full_node_api_2 = full_nodes[2]
     server_2 = full_node_api_2.server
 
-    ph = await wallet_0.wallet_state_manager.main_wallet.get_new_puzzlehash()
+    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet_0.wallet_state_manager)
 
     # wallet0 <-> sever0 <-> server1
 

chia/_tests/core/full_node/test_tx_processing_queue.py

@@ -9,8 +9,7 @@ from typing import Optional, cast
 import pytest
 from chia_rs.sized_bytes import bytes32
 
-from chia.full_node.tx_processing_queue import TransactionQueue, TransactionQueueFull
-from chia.types.transaction_queue_entry import TransactionQueueEntry
+from chia.full_node.tx_processing_queue import TransactionQueue, TransactionQueueEntry, TransactionQueueFull
 from chia.util.task_referencer import create_referenced_task
 
 log = logging.getLogger(__name__)

chia/_tests/core/large_block.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 import zstd
-
-from chia.types.full_block import FullBlock
+from chia_rs import FullBlock
 
 LARGE_BLOCK: FullBlock = FullBlock.from_bytes_unchecked(
     zstd.decompress(

chia/_tests/core/make_block_generator.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from chia_rs import G1Element, G2Element, PrivateKey
+from chia_rs import G1Element, G2Element, PrivateKey, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
@@ -11,7 +11,6 @@ from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.generator_types import BlockGenerator
-from chia.types.spend_bundle import SpendBundle
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_for_pk, solution_for_conditions
 
 GROUP_ORDER = 0x73EDA753299D7D483339D80809A1D80553BDA402FFFE5BFEFFFFFFFF00000001
@@ -25,7 +24,7 @@ def int_to_public_key(index: int) -> G1Element:
 
 def puzzle_hash_for_index(index: int, puzzle_hash_db: dict[bytes32, SerializedProgram]) -> bytes32:
     public_key: G1Element = int_to_public_key(index)
-    puzzle = SerializedProgram.from_program(puzzle_for_pk(public_key))
+    puzzle = puzzle_for_pk(public_key).to_serialized()
     puzzle_hash: bytes32 = puzzle.get_tree_hash()
     puzzle_hash_db[puzzle_hash] = puzzle
     return puzzle_hash
@@ -57,7 +56,7 @@ def make_spend_bundle(count: int) -> SpendBundle:
     for coin in coins:
         puzzle_reveal = puzzle_hash_db[coin.puzzle_hash]
         conditions = conditions_for_payment(coin)
-        solution = SerializedProgram.from_program(solution_for_conditions(conditions))
+        solution = solution_for_conditions(conditions).to_serialized()
         coin_spend = make_spend(coin, puzzle_reveal, solution)
         coin_spends.append(coin_spend)
 

chia/_tests/core/mempool/test_mempool.py

@@ -7,18 +7,18 @@ from typing import Callable, Optional
 
 import pytest
 from chia_rs import (
-    ELIGIBLE_FOR_FF,
-    ENABLE_KECCAK,
     ENABLE_KECCAK_OPS_OUTSIDE_GUARD,
     AugSchemeMPL,
+    CoinSpend,
+    FullBlock,
     G1Element,
     G2Element,
-    get_flags_for_height_and_constants,
+    SpendBundle,
+    SpendBundleConditions,
     run_block_generator2,
 )
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
-from clvm.casts import int_to_bytes
 from clvm_tools import binutils
 from clvm_tools.binutils import assemble
 
@@ -42,6 +42,7 @@ from chia.consensus.condition_costs import ConditionCost
 from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bitcoin_fee_estimator import create_bitcoin_fee_estimator
+from chia.full_node.eligible_coin_spends import run_for_cost
 from chia.full_node.fee_estimation import EmptyMempoolInfo, MempoolInfo
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.full_node.mempool import Mempool
@@ -49,9 +50,9 @@ from chia.full_node.mempool_check_conditions import get_puzzle_and_solution_for_
 from chia.full_node.mempool_manager import MEMPOOL_MIN_FEE_INCREASE, LineageInfoCache
 from chia.full_node.pending_tx_cache import ConflictTxCache, PendingTxCache
 from chia.protocols import full_node_protocol, wallet_protocol
+from chia.protocols.outbound_message import Message
 from chia.protocols.wallet_protocol import TransactionAck
 from chia.server.api_protocol import ApiMetadata
-from chia.server.outbound_message import Message
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
@@ -63,21 +64,19 @@ from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.clvm_cost import CLVMCost
-from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
-from chia.types.eligible_coin_spends import UnspentLineageInfo, run_for_cost
 from chia.types.fee_rate import FeeRate
-from chia.types.full_block import FullBlock
 from chia.types.generator_types import BlockGenerator
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
-from chia.types.mempool_item import MempoolItem
-from chia.types.spend_bundle import SpendBundle, estimate_fees
-from chia.types.spend_bundle_conditions import SpendBundleConditions
+from chia.types.mempool_item import MempoolItem, UnspentLineageInfo
+from chia.util.casts import int_to_bytes
 from chia.util.errors import Err
 from chia.util.hash import std_hash
 from chia.util.recursive_replace import recursive_replace
 from chia.wallet.conditions import AssertCoinAnnouncement, AssertPuzzleAnnouncement
+from chia.wallet.estimate_fees import estimate_fees
 
 BURN_PUZZLE_HASH = bytes32(b"0" * 32)
 BURN_PUZZLE_HASH_2 = bytes32(b"1" * 32)
@@ -1153,7 +1152,7 @@ class TestMempoolManager:
         assert sb1 is None
         assert status == MempoolInclusionStatus.FAILED
 
-        for i in range(0, 4):
+        for i in range(4):
             await full_node_1.farm_new_transaction_block(FarmNewBlockProtocol(bytes32(32 * b"0")))
 
         tx2: full_node_protocol.RespondTransaction = full_node_protocol.RespondTransaction(spend_bundle1)
@@ -2864,10 +2863,10 @@ class TestMaliciousGenerators:
         c = cs.coin
         coin_0 = Coin(c.parent_coin_info, bytes32([1] * 32), c.amount)
         coin_spend_0 = make_spend(coin_0, cs.puzzle_reveal, cs.solution)
-        new_bundle = recursive_replace(spend_bundle, "coin_spends", [coin_spend_0] + spend_bundle.coin_spends[1:])
+        new_bundle = recursive_replace(spend_bundle, "coin_spends", [coin_spend_0, *spend_bundle.coin_spends[1:]])
         assert spend_bundle is not None
         res = await full_node_1.full_node.add_transaction(new_bundle, new_bundle.name(), test=True)
-        assert res == (MempoolInclusionStatus.FAILED, Err.INVALID_SPEND_BUNDLE)
+        assert res == (MempoolInclusionStatus.FAILED, Err.WRONG_PUZZLE_HASH)
 
 
 coins = make_test_coins()
@@ -2932,10 +2931,8 @@ def test_items_by_feerate(items: list[MempoolItem], expected: list[Coin]) -> Non
         last_fpc = mi.fee_per_cost
 
 
-# make sure that after failing to pick 3 fast-forward spends, we skip
-# FF spends
-@pytest.mark.anyio
-async def test_skip_error_items() -> None:
+@pytest.mark.parametrize("old", [True, False])
+def test_timeout(old: bool) -> None:
     fee_estimator = create_bitcoin_fee_estimator(uint64(11000000000))
     mempool_info = MempoolInfo(
         CLVMCost(uint64(11000000000 * 3)),
@@ -2944,25 +2941,16 @@ async def test_skip_error_items() -> None:
     )
     mempool = Mempool(mempool_info, fee_estimator)
 
-    # all 50 items support fast forward
     for i in range(50):
-        item = mk_item(coins[i : i + 1], flags=[ELIGIBLE_FOR_FF], fee=0, cost=50)
+        item = mk_item(coins[i : i + 1], flags=[0], fee=0, cost=50)
         add_info = mempool.add_to_pool(item)
         assert add_info.error is None
 
-    called = 0
-
-    async def local_get_unspent_lineage_info(ph: bytes32) -> Optional[UnspentLineageInfo]:
-        nonlocal called
-        called += 1
-        raise RuntimeError("failed to find fast forward coin")
-
-    result = await mempool.create_block_generator(local_get_unspent_lineage_info, DEFAULT_CONSTANTS, uint32(10))
-    assert result is not None
-    generator, _, _, _ = result
+    create_block = mempool.create_block_generator if old else mempool.create_block_generator2
 
-    assert called == 3
-    assert generator.program == SerializedProgram.from_bytes(bytes.fromhex("ff01ff8080"))
+    # the timeout is set to 0, we should *always* fail with a timeout
+    generator = create_block(DEFAULT_CONSTANTS, uint32(10), 0.0)
+    assert generator is None
 
 
 def rand_hash() -> bytes32:
@@ -3146,11 +3134,7 @@ def make_test_spendbundle(coin: Coin, *, fee: int = 0, with_higher_cost: bool =
     return sb
 
 
-@pytest.mark.anyio
-async def test_aggregating_on_a_solution_then_a_more_cost_saving_one_appears() -> None:
-    async def get_unspent_lineage_info_for_puzzle_hash(_: bytes32) -> Optional[UnspentLineageInfo]:
-        assert False  # pragma: no cover
-
+def test_aggregating_on_a_solution_then_a_more_cost_saving_one_appears() -> None:
     def agg_and_add_sb_returning_cost_info(mempool: Mempool, spend_bundles: list[SpendBundle]) -> uint64:
         sb = SpendBundle.aggregate(spend_bundles)
         mi = mempool_item_from_spendbundle(sb)
@@ -3181,9 +3165,7 @@ async def test_aggregating_on_a_solution_then_a_more_cost_saving_one_appears() -
     sb_low_rate = make_test_spendbundle(coins[2], fee=highest_fee // 5)
     saved_cost_on_solution_A = agg_and_add_sb_returning_cost_info(mempool, [sb_A, sb_low_rate])
     invariant_check_mempool(mempool)
-    result = await mempool.create_bundle_from_mempool_items(
-        get_unspent_lineage_info_for_puzzle_hash, test_constants, uint32(0)
-    )
+    result = mempool.create_bundle_from_mempool_items(test_constants, uint32(0))
     assert result is not None
     agg, _ = result
     # Make sure both items would be processed
@@ -3202,9 +3184,7 @@ async def test_aggregating_on_a_solution_then_a_more_cost_saving_one_appears() -
     # If we process everything now, the 3 x ~3 FPC items get skipped because
     # sb_A1 gets picked before them (~10 FPC), so from then on only sb_A2 (~2 FPC)
     # would get picked
-    result = await mempool.create_bundle_from_mempool_items(
-        get_unspent_lineage_info_for_puzzle_hash, test_constants, uint32(0)
-    )
+    result = mempool.create_bundle_from_mempool_items(test_constants, uint32(0))
     assert result is not None
     agg, _ = result
     # The 3 items got skipped here
@@ -3221,11 +3201,8 @@ def test_get_puzzle_and_solution_for_coin_failure() -> None:
         get_puzzle_and_solution_for_coin(BlockGenerator(SerializedProgram.to(None), []), TEST_COIN, 0, test_constants)
 
 
-@pytest.mark.anyio
-async def test_create_block_generator() -> None:
-    async def get_unspent_lineage_info_for_puzzle_hash(_: bytes32) -> Optional[UnspentLineageInfo]:
-        assert False  # pragma: no cover
-
+@pytest.mark.parametrize("old", [True, False])
+def test_create_block_generator(old: bool) -> None:
     mempool_info = MempoolInfo(
         CLVMCost(uint64(11000000000 * 3)),
         FeeRate(uint64(1000000)),
@@ -3247,21 +3224,20 @@ async def test_create_block_generator() -> None:
         mempool.add_to_pool(mi)
         invariant_check_mempool(mempool)
 
-    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
-
-    assert set(additions) == expected_additions
+    create_block = mempool.create_block_generator if old else mempool.create_block_generator2
+    generator = create_block(test_constants, uint32(0), 10.0)
+    assert generator is not None
 
-    assert len(additions) == len(expected_additions)
-    assert signature == expected_signature
+    assert set(generator.additions) == expected_additions
+    assert len(generator.additions) == len(expected_additions)
+    assert generator.signature == expected_signature
 
     err, conds = run_block_generator2(
         bytes(generator.program),
         generator.generator_refs,
         test_constants.MAX_BLOCK_COST_CLVM,
         0,
-        signature,
+        generator.signature,
         None,
         test_constants,
     )
@@ -3278,26 +3254,14 @@ async def test_create_block_generator() -> None:
             assert Coin(spend.coin_id, add2[0], uint64(add2[1])) in expected_additions
             num_additions += 1
 
-    assert num_additions == len(additions)
+    assert num_additions == len(generator.additions)
     invariant_check_mempool(mempool)
 
 
-def test_flags_for_height() -> None:
-    # the keccak operator is supposed to be enabled at soft-fork 6 height
-    flags = get_flags_for_height_and_constants(DEFAULT_CONSTANTS.SOFT_FORK6_HEIGHT, DEFAULT_CONSTANTS)
-    print(f"{flags:x}")
-    assert (flags & ENABLE_KECCAK) != 0
-
-    flags = get_flags_for_height_and_constants(DEFAULT_CONSTANTS.SOFT_FORK6_HEIGHT - 1, DEFAULT_CONSTANTS)
-    print(f"{flags:x}")
-    assert (flags & ENABLE_KECCAK) == 0
-
-
 def test_keccak() -> None:
     # the keccak operator is 62. The assemble() function doesn't support it
     # (yet)
 
-    # keccak256 is available when the softfork has activated
     keccak_prg = Program.to(
         assemble(
             "(softfork (q . 1134) (q . 1) (q a (i "
@@ -3308,11 +3272,6 @@ def test_keccak() -> None:
         )
     )
 
-    cost, ret = keccak_prg.run_with_flags(1215, ENABLE_KECCAK, [])
-    assert cost == 1215
-    assert ret.atom == b""
-
-    # keccak is ignored when the softfork has not activated
     cost, ret = keccak_prg.run_with_flags(1215, 0, [])
     assert cost == 1215
     assert ret.atom == b""
@@ -3327,12 +3286,7 @@ def test_keccak() -> None:
         )
     )
     with pytest.raises(ValueError, match="clvm raise"):
-        keccak_prg.run_with_flags(1215, ENABLE_KECCAK, [])
-
-    # keccak is ignored when the softfork has not activated
-    cost, ret = keccak_prg.run_with_flags(1215, 0, [])
-    assert cost == 1215
-    assert ret.atom == b""
+        keccak_prg.run_with_flags(1215, 0, [])
 
     # === HARD FORK ===
     # new operators *outside* the softfork guard
@@ -3346,7 +3300,7 @@ def test_keccak() -> None:
         )
     )
 
-    cost, ret = keccak_prg.run_with_flags(994, ENABLE_KECCAK | ENABLE_KECCAK_OPS_OUTSIDE_GUARD, [])
+    cost, ret = keccak_prg.run_with_flags(994, ENABLE_KECCAK_OPS_OUTSIDE_GUARD, [])
     assert cost == 994
     assert ret.atom == b""
 
@@ -3356,11 +3310,7 @@ async def test_lineage_cache(seeded_random: random.Random) -> None:
     called = 0
 
     info1 = UnspentLineageInfo(
-        bytes32.random(seeded_random),
-        uint64.from_bytes(seeded_random.randbytes(8)),
-        bytes32.random(seeded_random),
-        uint64.from_bytes(seeded_random.randbytes(8)),
-        bytes32.random(seeded_random),
+        bytes32.random(seeded_random), bytes32.random(seeded_random), bytes32.random(seeded_random)
     )
 
     async def callback1(ph: bytes32) -> Optional[UnspentLineageInfo]:

chia/_tests/core/mempool/test_mempool_fee_estimator.py

@@ -74,7 +74,7 @@ async def test_fee_increase() -> None:
         for i in range(300, 700):
             i = uint32(i)
             items = []
-            for _ in range(0, 20):
+            for _ in range(20):
                 fee = uint64(0)
                 included_height = uint32(random.randint(i - 60, i - 1))
                 cost = uint64(5000000)

chia/_tests/core/mempool/test_mempool_item_queries.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from chia_rs import AugSchemeMPL, Coin, Program
+from chia_rs import AugSchemeMPL, Coin, CoinSpend, Program, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
@@ -13,10 +13,8 @@ from chia.full_node.fee_estimation import MempoolInfo
 from chia.full_node.mempool import Mempool
 from chia.types.blockchain_format.program import INFINITE_COST
 from chia.types.clvm_cost import CLVMCost
-from chia.types.coin_spend import CoinSpend
 from chia.types.fee_rate import FeeRate
 from chia.types.mempool_item import MempoolItem
-from chia.types.spend_bundle import SpendBundle
 
 MEMPOOL_INFO = MempoolInfo(
     max_size_in_cost=CLVMCost(uint64(INFINITE_COST * 10)),