chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/_tests/core/mempool/test_mempool_fee_protocol.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import datetime
-from typing import List, Tuple, Union
+from typing import Union
 
 import pytest
 
@@ -20,11 +20,11 @@ from chia.wallet.wallet import Wallet
 
 @pytest.mark.anyio
 async def test_protocol_messages(
-    simulator_and_wallet: Tuple[
-        List[Union[FullNodeAPI, FullNodeSimulator]], List[Tuple[Wallet, ChiaServer]], BlockTools
-    ]
+    simulator_and_wallet: tuple[
+        list[Union[FullNodeAPI, FullNodeSimulator]], list[tuple[Wallet, ChiaServer]], BlockTools
+    ],
 ) -> None:
-    full_nodes, wallets, bt = simulator_and_wallet
+    full_nodes, _wallets, bt = simulator_and_wallet
     a_wallet = bt.get_pool_wallet_tool()
     reward_ph = a_wallet.get_new_puzzlehash()
     blocks = bt.get_consecutive_blocks(

chia/_tests/core/mempool/test_mempool_item_queries.py

@@ -1,18 +1,16 @@
 from __future__ import annotations
 
-from typing import List
-
 from chia_rs import AugSchemeMPL, Coin, Program
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.core.mempool.test_mempool_manager import TEST_HEIGHT, make_bundle_spends_map_and_fee
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bitcoin_fee_estimator import create_bitcoin_fee_estimator
 from chia.full_node.bundle_tools import simple_solution_generator
 from chia.full_node.fee_estimation import MempoolInfo
 from chia.full_node.mempool import Mempool
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
 from chia.types.blockchain_format.program import INFINITE_COST
 from chia.types.clvm_cost import CLVMCost
 from chia.types.coin_spend import CoinSpend
@@ -43,7 +41,7 @@ OTHER_COIN_3 = Coin(bytes32(b"5" * 32), OTHER_PUZZLE_HASH, uint64(1000))
 EMPTY_SIGNATURE = AugSchemeMPL.aggregate([])
 
 
-def make_item(coin_spends: List[CoinSpend]) -> MempoolItem:
+def make_item(coin_spends: list[CoinSpend]) -> MempoolItem:
     spend_bundle = SpendBundle(coin_spends, EMPTY_SIGNATURE)
     generator = simple_solution_generator(spend_bundle)
     npc_result = get_name_puzzle_conditions(

chia/_tests/core/mempool/test_mempool_manager.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import dataclasses
 import logging
-from typing import Any, Awaitable, Callable, Collection, Dict, List, Optional, Set, Tuple
+from collections.abc import Awaitable, Collection
+from typing import Any, Callable, ClassVar, Optional
 
 import pytest
 from chia_rs import ELIGIBLE_FOR_DEDUP, ELIGIBLE_FOR_FF, AugSchemeMPL, G2Element, get_conditions_from_spendbundle
@@ -11,6 +12,7 @@ from chiabip158 import PyBIP158
 from chia._tests.conftest import ConsensusMode
 from chia._tests.util.misc import 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.constants import ConsensusConstants
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.mempool import MAX_SKIPPED_ITEMS, PRIORITY_TX_THRESHOLD
@@ -96,19 +98,19 @@ class TestBlockRecord:
         return self.timestamp is not None
 
 
-async def zero_calls_get_coin_records(coin_ids: Collection[bytes32]) -> List[CoinRecord]:
+async def zero_calls_get_coin_records(coin_ids: Collection[bytes32]) -> list[CoinRecord]:
     assert len(coin_ids) == 0
     return []
 
 
-async def get_coin_records_for_test_coins(coin_ids: Collection[bytes32]) -> List[CoinRecord]:
+async def get_coin_records_for_test_coins(coin_ids: Collection[bytes32]) -> list[CoinRecord]:
     test_coin_records = {
         TEST_COIN_ID: TEST_COIN_RECORD,
         TEST_COIN_ID2: TEST_COIN_RECORD2,
         TEST_COIN_ID3: TEST_COIN_RECORD3,
     }
 
-    ret: List[CoinRecord] = []
+    ret: list[CoinRecord] = []
     for name in coin_ids:
         r = test_coin_records.get(name)
         if r is not None:
@@ -131,7 +133,7 @@ def create_test_block_record(*, height: uint32 = TEST_HEIGHT, timestamp: uint64
 
 
 async def instantiate_mempool_manager(
-    get_coin_records: Callable[[Collection[bytes32]], Awaitable[List[CoinRecord]]],
+    get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
     *,
     block_height: uint32 = TEST_HEIGHT,
     block_timestamp: uint64 = TEST_TIMESTAMP,
@@ -147,11 +149,11 @@ async def instantiate_mempool_manager(
 
 async def setup_mempool_with_coins(
     *,
-    coin_amounts: List[int],
+    coin_amounts: list[int],
     max_block_clvm_cost: Optional[int] = None,
     max_tx_clvm_cost: Optional[uint64] = None,
     mempool_block_buffer: Optional[int] = None,
-) -> Tuple[MempoolManager, List[Coin]]:
+) -> tuple[MempoolManager, list[Coin]]:
     coins = []
     test_coin_records = {}
     for amount in coin_amounts:
@@ -159,8 +161,8 @@ async def setup_mempool_with_coins(
         coins.append(coin)
         test_coin_records[coin.name()] = CoinRecord(coin, uint32(0), uint32(0), False, uint64(0))
 
-    async def get_coin_records(coin_ids: Collection[bytes32]) -> List[CoinRecord]:
-        ret: List[CoinRecord] = []
+    async def get_coin_records(coin_ids: Collection[bytes32]) -> list[CoinRecord]:
+        ret: list[CoinRecord] = []
         for name in coin_ids:
             r = test_coin_records.get(name)
             if r is not None:
@@ -169,7 +171,7 @@ async def setup_mempool_with_coins(
 
     constants = DEFAULT_CONSTANTS
     if max_block_clvm_cost is not None:
-        constants = constants.replace(MAX_BLOCK_COST_CLVM=uint64(max_block_clvm_cost))
+        constants = constants.replace(MAX_BLOCK_COST_CLVM=uint64(max_block_clvm_cost + TEST_BLOCK_OVERHEAD))
     if mempool_block_buffer is not None:
         constants = constants.replace(MEMPOOL_BLOCK_BUFFER=uint8(mempool_block_buffer))
     mempool_manager = await instantiate_mempool_manager(
@@ -191,7 +193,7 @@ def make_test_conds(
     before_seconds_relative: Optional[int] = None,
     before_seconds_absolute: Optional[int] = None,
     cost: int = 0,
-    spend_ids: List[bytes32] = [TEST_COIN_ID],
+    spend_ids: list[bytes32] = [TEST_COIN_ID],
 ) -> SpendBundleConditions:
     return SpendBundleConditions(
         [
@@ -228,55 +230,57 @@ def make_test_conds(
         0,
         0,
         False,
+        0,
+        0,
     )
 
 
 class TestCheckTimeLocks:
-    COIN_CONFIRMED_HEIGHT = uint32(10)
-    COIN_TIMESTAMP = uint64(10000)
-    PREV_BLOCK_HEIGHT = uint32(15)
-    PREV_BLOCK_TIMESTAMP = uint64(10150)
+    COIN_CONFIRMED_HEIGHT: ClassVar[uint32] = uint32(10)
+    COIN_TIMESTAMP: ClassVar[uint64] = uint64(10000)
+    PREV_BLOCK_HEIGHT: ClassVar[uint32] = uint32(15)
+    PREV_BLOCK_TIMESTAMP: ClassVar[uint64] = uint64(10150)
 
-    COIN_RECORD = CoinRecord(
+    COIN_RECORD: ClassVar[CoinRecord] = CoinRecord(
         TEST_COIN,
         confirmed_block_index=uint32(COIN_CONFIRMED_HEIGHT),
         spent_block_index=uint32(0),
         coinbase=False,
         timestamp=COIN_TIMESTAMP,
     )
-    REMOVALS: Dict[bytes32, CoinRecord] = {TEST_COIN.name(): COIN_RECORD}
+    REMOVALS: ClassVar[dict[bytes32, CoinRecord]] = {TEST_COIN.name(): COIN_RECORD}
 
     @pytest.mark.parametrize(
         "conds,expected",
         [
             (make_test_conds(height_relative=5), None),
             (make_test_conds(height_relative=6), Err.ASSERT_HEIGHT_RELATIVE_FAILED),
-            (make_test_conds(height_absolute=15), None),
-            (make_test_conds(height_absolute=16), Err.ASSERT_HEIGHT_ABSOLUTE_FAILED),
+            (make_test_conds(height_absolute=PREV_BLOCK_HEIGHT), None),
+            (make_test_conds(height_absolute=uint32(PREV_BLOCK_HEIGHT + 1)), Err.ASSERT_HEIGHT_ABSOLUTE_FAILED),
             (make_test_conds(seconds_relative=150), None),
             (make_test_conds(seconds_relative=151), Err.ASSERT_SECONDS_RELATIVE_FAILED),
-            (make_test_conds(seconds_absolute=10150), None),
-            (make_test_conds(seconds_absolute=10151), Err.ASSERT_SECONDS_ABSOLUTE_FAILED),
+            (make_test_conds(seconds_absolute=PREV_BLOCK_TIMESTAMP), None),
+            (make_test_conds(seconds_absolute=uint64(PREV_BLOCK_TIMESTAMP + 1)), Err.ASSERT_SECONDS_ABSOLUTE_FAILED),
             # the coin's confirmed height is 10
             (make_test_conds(birth_height=9), Err.ASSERT_MY_BIRTH_HEIGHT_FAILED),
             (make_test_conds(birth_height=10), None),
             (make_test_conds(birth_height=11), Err.ASSERT_MY_BIRTH_HEIGHT_FAILED),
             # coin timestamp is 10000
-            (make_test_conds(birth_seconds=9999), Err.ASSERT_MY_BIRTH_SECONDS_FAILED),
-            (make_test_conds(birth_seconds=10000), None),
-            (make_test_conds(birth_seconds=10001), Err.ASSERT_MY_BIRTH_SECONDS_FAILED),
+            (make_test_conds(birth_seconds=uint64(COIN_TIMESTAMP - 1)), Err.ASSERT_MY_BIRTH_SECONDS_FAILED),
+            (make_test_conds(birth_seconds=COIN_TIMESTAMP), None),
+            (make_test_conds(birth_seconds=uint64(COIN_TIMESTAMP + 1)), Err.ASSERT_MY_BIRTH_SECONDS_FAILED),
             # the coin is 5 blocks old in this test
             (make_test_conds(before_height_relative=5), Err.ASSERT_BEFORE_HEIGHT_RELATIVE_FAILED),
             (make_test_conds(before_height_relative=6), None),
             # The block height is 15
-            (make_test_conds(before_height_absolute=15), Err.ASSERT_BEFORE_HEIGHT_ABSOLUTE_FAILED),
-            (make_test_conds(before_height_absolute=16), None),
+            (make_test_conds(before_height_absolute=PREV_BLOCK_HEIGHT), Err.ASSERT_BEFORE_HEIGHT_ABSOLUTE_FAILED),
+            (make_test_conds(before_height_absolute=uint64(PREV_BLOCK_HEIGHT + 1)), None),
             # the coin is 150 seconds old in this test
             (make_test_conds(before_seconds_relative=150), Err.ASSERT_BEFORE_SECONDS_RELATIVE_FAILED),
             (make_test_conds(before_seconds_relative=151), None),
             # The block timestamp is 10150
-            (make_test_conds(before_seconds_absolute=10150), Err.ASSERT_BEFORE_SECONDS_ABSOLUTE_FAILED),
-            (make_test_conds(before_seconds_absolute=10151), None),
+            (make_test_conds(before_seconds_absolute=PREV_BLOCK_TIMESTAMP), Err.ASSERT_BEFORE_SECONDS_ABSOLUTE_FAILED),
+            (make_test_conds(before_seconds_absolute=uint64(PREV_BLOCK_TIMESTAMP + 1)), None),
         ],
     )
     def test_conditions(
@@ -286,7 +290,7 @@ class TestCheckTimeLocks:
     ) -> None:
         assert (
             mempool_check_time_locks(
-                self.REMOVALS,
+                dict(self.REMOVALS),
                 conds,
                 self.PREV_BLOCK_HEIGHT,
                 self.PREV_BLOCK_TIMESTAMP,
@@ -379,7 +383,7 @@ def test_compute_assert_height(conds: SpendBundleConditions, expected: TimelockC
 
 
 def spend_bundle_from_conditions(
-    conditions: List[List[Any]], coin: Coin = TEST_COIN, aggsig: G2Element = G2Element()
+    conditions: list[list[Any]], coin: Coin = TEST_COIN, aggsig: G2Element = G2Element()
 ) -> SpendBundle:
     solution = SerializedProgram.to(conditions)
     coin_spend = make_spend(coin, IDENTITY_PUZZLE, solution)
@@ -388,7 +392,7 @@ def spend_bundle_from_conditions(
 
 async def add_spendbundle(
     mempool_manager: MempoolManager, sb: SpendBundle, sb_name: bytes32
-) -> Tuple[Optional[uint64], MempoolInclusionStatus, Optional[Err]]:
+) -> tuple[Optional[uint64], MempoolInclusionStatus, Optional[Err]]:
     sbc = await mempool_manager.pre_validate_spendbundle(sb, sb_name)
     ret = await mempool_manager.add_spend_bundle(sb, sbc, sb_name, TEST_HEIGHT)
     invariant_check_mempool(mempool_manager.mempool)
@@ -397,10 +401,10 @@ async def add_spendbundle(
 
 async def generate_and_add_spendbundle(
     mempool_manager: MempoolManager,
-    conditions: List[List[Any]],
+    conditions: list[list[Any]],
     coin: Coin = TEST_COIN,
     aggsig: G2Element = G2Element(),
-) -> Tuple[SpendBundle, bytes32, Tuple[Optional[uint64], MempoolInclusionStatus, Optional[Err]]]:
+) -> tuple[SpendBundle, bytes32, tuple[Optional[uint64], MempoolInclusionStatus, Optional[Err]]]:
     sb = spend_bundle_from_conditions(conditions, coin, aggsig)
     sb_name = sb.name()
     result = await add_spendbundle(mempool_manager, sb, sb_name)
@@ -409,9 +413,9 @@ async def generate_and_add_spendbundle(
 
 def make_bundle_spends_map_and_fee(
     spend_bundle: SpendBundle, conds: SpendBundleConditions
-) -> Tuple[Dict[bytes32, BundleCoinSpend], uint64]:
-    bundle_coin_spends: Dict[bytes32, BundleCoinSpend] = {}
-    eligibility_and_additions: Dict[bytes32, EligibilityAndAdditions] = {}
+) -> tuple[dict[bytes32, BundleCoinSpend], uint64]:
+    bundle_coin_spends: dict[bytes32, BundleCoinSpend] = {}
+    eligibility_and_additions: dict[bytes32, EligibilityAndAdditions] = {}
     removals_amount = 0
     additions_amount = 0
     for spend in conds.spends:
@@ -551,7 +555,7 @@ async def test_reserve_fee_condition() -> None:
 
 @pytest.mark.anyio
 async def test_unknown_unspent() -> None:
-    async def get_coin_records(_: Collection[bytes32]) -> List[CoinRecord]:
+    async def get_coin_records(_: Collection[bytes32]) -> list[CoinRecord]:
         return []
 
     mempool_manager = await instantiate_mempool_manager(get_coin_records)
@@ -598,7 +602,7 @@ async def test_sb_twice_with_eligible_coin_and_different_spends_order() -> None:
     sk = AugSchemeMPL.key_gen(b"6" * 32)
     g1 = sk.get_g1()
     sig = AugSchemeMPL.sign(sk, IDENTITY_PUZZLE_HASH, g1)
-    sb2_conditions: List[List[Any]] = [
+    sb2_conditions: list[list[Any]] = [
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 3],
         [ConditionOpcode.AGG_SIG_UNSAFE, bytes(g1), IDENTITY_PUZZLE_HASH],
     ]
@@ -726,7 +730,7 @@ def test_optional_max() -> None:
 
 
 def mk_item(
-    coins: List[Coin],
+    coins: list[Coin],
     *,
     cost: int = 1,
     fee: int = 0,
@@ -762,8 +766,8 @@ def mk_item(
     )
 
 
-def make_test_coins() -> List[Coin]:
-    ret: List[Coin] = []
+def make_test_coins() -> list[Coin]:
+    ret: list[Coin] = []
     for i in range(5):
         ret.append(Coin(height_hash(i), height_hash(i + 100), uint64(i * 100)))
     return ret
@@ -904,7 +908,7 @@ coins = make_test_coins()
         ),
     ],
 )
-def test_can_replace(existing_items: List[MempoolItem], new_item: MempoolItem, expected: bool) -> None:
+def test_can_replace(existing_items: list[MempoolItem], new_item: MempoolItem, expected: bool) -> None:
     removals = {c.name() for c in new_item.spend_bundle.removals()}
     assert can_replace(existing_items, removals, new_item) == expected
 
@@ -956,10 +960,10 @@ async def test_get_items_not_in_filter() -> None:
 
 @pytest.mark.anyio
 async def test_total_mempool_fees() -> None:
-    coin_records: Dict[bytes32, CoinRecord] = {}
+    coin_records: dict[bytes32, CoinRecord] = {}
 
-    async def get_coin_records(coin_ids: Collection[bytes32]) -> List[CoinRecord]:
-        ret: List[CoinRecord] = []
+    async def get_coin_records(coin_ids: Collection[bytes32]) -> list[CoinRecord]:
+        ret: list[CoinRecord] = []
         for name in coin_ids:
             r = coin_records.get(name)
             if r is not None:
@@ -997,7 +1001,7 @@ async def test_create_bundle_from_mempool(reverse_tx_order: bool) -> None:
     async def get_unspent_lineage_info_for_puzzle_hash(_: bytes32) -> Optional[UnspentLineageInfo]:
         assert False  # pragma: no cover
 
-    async def make_coin_spends(coins: List[Coin], *, high_fees: bool = True) -> List[CoinSpend]:
+    async def make_coin_spends(coins: list[Coin], *, high_fees: bool = True) -> list[CoinSpend]:
         spends_list = []
         for i in range(0, len(coins)):
             coin_spend = make_spend(
@@ -1010,7 +1014,7 @@ async def test_create_bundle_from_mempool(reverse_tx_order: bool) -> None:
             spends_list.append(coin_spend)
         return spends_list
 
-    async def send_spends_to_mempool(coin_spends: List[CoinSpend]) -> None:
+    async def send_spends_to_mempool(coin_spends: list[CoinSpend]) -> None:
         g2 = G2Element()
         for cs in coin_spends:
             sb = SpendBundle([cs], g2)
@@ -1035,36 +1039,63 @@ async def test_create_bundle_from_mempool(reverse_tx_order: bool) -> None:
 @pytest.mark.parametrize("num_skipped_items", [PRIORITY_TX_THRESHOLD, MAX_SKIPPED_ITEMS])
 @pytest.mark.anyio
 async def test_create_bundle_from_mempool_on_max_cost(num_skipped_items: int, caplog: pytest.LogCaptureFixture) -> None:
+    """
+    This test exercises the path where an item's inclusion would exceed the
+    maximum cumulative cost, so it gets skipped as a result.
+
+    NOTE:
+      1. After PRIORITY_TX_THRESHOLD, we skip items with eligible coins.
+      2. After skipping MAX_SKIPPED_ITEMS, we stop processing further items.
+    """
+
     async def get_unspent_lineage_info_for_puzzle_hash(_: bytes32) -> Optional[UnspentLineageInfo]:
         assert False  # pragma: no cover
 
-    # This test exercises the path where an item's inclusion would exceed the
-    # maximum cumulative cost, so it gets skipped as a result
+    MAX_BLOCK_CLVM_COST = 550_000_000
 
-    # NOTE:
-    # 1. After PRIORITY_TX_THRESHOLD, we skip items with eligible coins.
-    # 2. After skipping MAX_SKIPPED_ITEMS, we stop processing further items.
+    mempool_manager, coins = await setup_mempool_with_coins(
+        coin_amounts=list(range(1_000_000_000, 1_000_000_030)),
+        max_block_clvm_cost=MAX_BLOCK_CLVM_COST,
+        max_tx_clvm_cost=uint64(MAX_BLOCK_CLVM_COST),
+        mempool_block_buffer=20,
+    )
 
     async def make_and_send_big_cost_sb(coin: Coin) -> None:
+        """
+        Creates a spend bundle with a big enough cost that gets it close to the
+        maximum block clvm cost limit.
+        """
         conditions = []
         sk = AugSchemeMPL.key_gen(b"7" * 32)
         g1 = sk.get_g1()
         sig = AugSchemeMPL.sign(sk, IDENTITY_PUZZLE_HASH, g1)
         aggsig = G2Element()
-        for _ in range(169):
+        # Let's get as close to `MAX_BLOCK_CLVM_COST` (550_000_000) as possible.
+        # We start by accounting for execution cost
+        spend_bundle_cost = 44
+        # And then the created coin
+        conditions.append([ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount - 10_000_000])
+        TEST_CREATE_COIN_SPEND_BYTESIZE = 93
+        TEST_CREATE_COIN_CONDITION_COST = (
+            ConditionCost.CREATE_COIN.value + TEST_CREATE_COIN_SPEND_BYTESIZE * DEFAULT_CONSTANTS.COST_PER_BYTE
+        )
+        spend_bundle_cost += TEST_CREATE_COIN_CONDITION_COST
+        # We're using agg sig conditions to increase the spend bundle's cost
+        # and reach our target cost.
+        TEST_AGG_SIG_SPEND_BYTESIZE = 88
+        TEST_AGGSIG_CONDITION_COST = (
+            ConditionCost.AGG_SIG.value + TEST_AGG_SIG_SPEND_BYTESIZE * DEFAULT_CONSTANTS.COST_PER_BYTE
+        )
+        while spend_bundle_cost + TEST_AGGSIG_CONDITION_COST < MAX_BLOCK_CLVM_COST:
             conditions.append([ConditionOpcode.AGG_SIG_UNSAFE, g1, IDENTITY_PUZZLE_HASH])
             aggsig += sig
-        conditions.append([ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount - 10_000_000])
-        # Create a spend bundle with a big enough cost that gets it close to the limit
+            spend_bundle_cost += TEST_AGGSIG_CONDITION_COST
+        # We now have a spend bundle with a big enough cost that gets it close to the limit
         _, _, res = await generate_and_add_spendbundle(mempool_manager, conditions, coin, aggsig)
-        assert res[1] == MempoolInclusionStatus.SUCCESS
+        cost, status, _ = res
+        assert status == MempoolInclusionStatus.SUCCESS
+        assert cost == spend_bundle_cost
 
-    mempool_manager, coins = await setup_mempool_with_coins(
-        coin_amounts=list(range(1_000_000_000, 1_000_000_030)),
-        max_block_clvm_cost=550_000_000,
-        max_tx_clvm_cost=uint64(550_000_000),
-        mempool_block_buffer=20,
-    )
     # Create the spend bundles with a big enough cost that they get close to the limit
     for i in range(num_skipped_items):
         await make_and_send_big_cost_sb(coins[i])
@@ -1149,9 +1180,9 @@ async def test_create_bundle_from_mempool_on_max_cost(num_skipped_items: int, ca
 async def test_assert_before_expiration(
     opcode: ConditionOpcode, arg: int, expect_eviction: bool, expect_limit: Optional[int]
 ) -> None:
-    async def get_coin_records(coin_ids: Collection[bytes32]) -> List[CoinRecord]:
+    async def get_coin_records(coin_ids: Collection[bytes32]) -> list[CoinRecord]:
         all_coins = {TEST_COIN.name(): CoinRecord(TEST_COIN, uint32(5), uint32(0), False, uint64(9900))}
-        ret: List[CoinRecord] = []
+        ret: list[CoinRecord] = []
         for name in coin_ids:
             r = all_coins.get(name)
             if r is not None:
@@ -1187,9 +1218,9 @@ async def test_assert_before_expiration(
         assert expect_limit is not None
         item = mempool_manager.get_mempool_item(bundle_name)
         assert item is not None
-        if opcode in [co.ASSERT_BEFORE_SECONDS_ABSOLUTE, co.ASSERT_BEFORE_SECONDS_RELATIVE]:
+        if opcode in {co.ASSERT_BEFORE_SECONDS_ABSOLUTE, co.ASSERT_BEFORE_SECONDS_RELATIVE}:
             assert item.assert_before_seconds == expect_limit
-        elif opcode in [co.ASSERT_BEFORE_HEIGHT_ABSOLUTE, co.ASSERT_BEFORE_HEIGHT_RELATIVE]:
+        elif opcode in {co.ASSERT_BEFORE_HEIGHT_ABSOLUTE, co.ASSERT_BEFORE_HEIGHT_RELATIVE}:
             assert item.assert_before_height == expect_limit
         else:
             assert False
@@ -1209,7 +1240,7 @@ def make_test_spendbundle(coin: Coin, *, fee: int = 0, eligible_spend: bool = Fa
 async def send_spendbundle(
     mempool_manager: MempoolManager,
     sb: SpendBundle,
-    expected_result: Tuple[MempoolInclusionStatus, Optional[Err]] = (MempoolInclusionStatus.SUCCESS, None),
+    expected_result: tuple[MempoolInclusionStatus, Optional[Err]] = (MempoolInclusionStatus.SUCCESS, None),
 ) -> None:
     result = await add_spendbundle(mempool_manager, sb, sb.name())
     assert (result[1], result[2]) == expected_result
@@ -1220,7 +1251,7 @@ async def make_and_send_spendbundle(
     coin: Coin,
     *,
     fee: int = 0,
-    expected_result: Tuple[MempoolInclusionStatus, Optional[Err]] = (MempoolInclusionStatus.SUCCESS, None),
+    expected_result: tuple[MempoolInclusionStatus, Optional[Err]] = (MempoolInclusionStatus.SUCCESS, None),
 ) -> SpendBundle:
     sb = make_test_spendbundle(coin, fee=fee)
     await send_spendbundle(mempool_manager, sb, expected_result)
@@ -1529,8 +1560,8 @@ async def test_coin_spending_different_ways_then_finding_it_spent_in_new_peak(ne
     coin_id = coin.name()
     test_coin_records = {coin_id: CoinRecord(coin, uint32(0), uint32(0), False, uint64(0))}
 
-    async def get_coin_records(coin_ids: Collection[bytes32]) -> List[CoinRecord]:
-        ret: List[CoinRecord] = []
+    async def get_coin_records(coin_ids: Collection[bytes32]) -> list[CoinRecord]:
+        ret: list[CoinRecord] = []
         for name in coin_ids:
             r = test_coin_records.get(name)
             if r is not None:
@@ -1592,7 +1623,7 @@ async def test_identical_spend_aggregation_e2e(
     def get_sb_names_by_coin_id(
         full_node_api: FullNodeSimulator,
         spent_coin_id: bytes32,
-    ) -> Set[bytes32]:
+    ) -> set[bytes32]:
         return {
             i.spend_bundle_name
             for i in full_node_api.full_node.mempool_manager.mempool.get_items_by_coin_id(spent_coin_id)
@@ -1616,7 +1647,7 @@ async def test_identical_spend_aggregation_e2e(
 
     async def make_setup_and_coins(
         full_node_api: FullNodeSimulator, wallet_node: WalletNode
-    ) -> Tuple[Wallet, list[WalletCoinRecord], bytes32]:
+    ) -> tuple[Wallet, list[WalletCoinRecord], bytes32]:
         wallet = wallet_node.wallet_state_manager.main_wallet
         ph = await wallet.get_new_puzzlehash()
         phs = [await wallet.get_new_puzzlehash() for _ in range(3)]
@@ -1712,7 +1743,7 @@ async def test_identical_spend_aggregation_e2e(
     assert tx_f.spend_bundle is not None
     # Create transaction E now that spends e_coin to create another eligible
     # coin as well as the announcement consumed by D and F
-    conditions: List[List[Any]] = [
+    conditions: list[list[Any]] = [
         [ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, 42],
         [ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, message],
     ]
@@ -1898,7 +1929,7 @@ async def test_identical_spend_aggregation_e2e(
         ),
     ],
 )
-async def test_mempool_timelocks(cond1: List[object], cond2: List[object], expected: Optional[Err]) -> None:
+async def test_mempool_timelocks(cond1: list[object], cond2: list[object], expected: Optional[Err]) -> None:
     coins = []
     test_coin_records = {}
 
@@ -1909,8 +1940,8 @@ async def test_mempool_timelocks(cond1: List[object], cond2: List[object], expec
     coins.append(coin)
     test_coin_records[coin.name()] = CoinRecord(coin, uint32(20), uint32(0), False, uint64(2000))
 
-    async def get_coin_records(coin_ids: Collection[bytes32]) -> List[CoinRecord]:
-        ret: List[CoinRecord] = []
+    async def get_coin_records(coin_ids: Collection[bytes32]) -> list[CoinRecord]:
+        ret: list[CoinRecord] = []
         for name in coin_ids:
             r = test_coin_records.get(name)
             if r is not None:
@@ -1987,7 +2018,7 @@ async def test_fill_rate_block_validation(
 
     async def fill_mempool_with_test_sbs(
         full_node_api: FullNodeSimulator,
-    ) -> List[Tuple[bytes32, SerializedProgram, bytes32]]:
+    ) -> list[tuple[bytes32, SerializedProgram, bytes32]]:
         coins_and_puzzles = []
         # Create different puzzles and use different (parent) coins to reduce
         # the effects of block compression as much as possible.
@@ -2015,9 +2046,7 @@ async def test_fill_rate_block_validation(
         # and without them we won't be able to get the test bundle in.
         # This defaults to `MAX_BLOCK_COST_CLVM // 2`
         full_node_api.full_node._mempool_manager.max_tx_clvm_cost = max_block_clvm_cost
-        # This defaults to `MAX_BLOCK_COST_CLVM * BLOCK_SIZE_LIMIT_FACTOR`
-        # TODO: Revisit this when we eventually raise the fille rate to 100%
-        # and `BLOCK_SIZE_LIMIT_FACTOR` is no longer relevant.
+        # This defaults to `MAX_BLOCK_COST_CLVM - BLOCK_OVERHEAD`
         full_node_api.full_node._mempool_manager.mempool.mempool_info = dataclasses.replace(
             full_node_api.full_node._mempool_manager.mempool.mempool_info,
             max_block_clvm_cost=CLVMCost(max_block_clvm_cost),

chia/_tests/core/mempool/test_mempool_performance.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
-from typing import List
-
 import pytest
 
-from chia._tests.util.misc import BenchmarkRunner, add_blocks_in_batches, wallet_height_at_least
+from chia._tests.util.misc import BenchmarkRunner, wallet_height_at_least
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
 from chia._tests.util.time_out_assert import time_out_assert
+from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.types.full_block import FullBlock
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.peer_info import PeerInfo
@@ -24,7 +23,7 @@ async def wallet_balance_at_least(wallet_node: WalletNode, balance: uint128) ->
 @pytest.mark.anyio
 async def test_mempool_update_performance(
     wallet_nodes_mempool_perf: OldSimulatorsAndWallets,
-    default_400_blocks: List[FullBlock],
+    default_400_blocks: list[FullBlock],
     self_hostname: str,
     benchmark_runner: BenchmarkRunner,
 ) -> None:

chia/_tests/core/mempool/test_singleton_fast_forward.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import pytest
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
@@ -17,7 +17,7 @@ from chia._tests.core.mempool.test_mempool_manager import (
     spend_bundle_from_conditions,
 )
 from chia._tests.util.key_tool import KeyTool
-from chia.clvm.spend_sim import SimClient, SpendSim, sim_and_client
+from chia._tests.util.spend_sim import SimClient, SpendSim, sim_and_client
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -206,7 +206,7 @@ def test_perform_the_fast_forward() -> None:
         parent_parent_id=test_child_coin.parent_coin_info,
     )
     # Start from a fresh state of fast forward spends
-    fast_forward_spends: Dict[bytes32, UnspentLineageInfo] = {}
+    fast_forward_spends: dict[bytes32, UnspentLineageInfo] = {}
     # Perform the fast forward on the test coin (the grandparent)
     new_coin_spend, patched_additions = perform_the_fast_forward(
         test_unspent_lineage_info, test_spend_data, fast_forward_spends
@@ -246,14 +246,14 @@ def sign_delegated_puz(del_puz: Program, coin: Coin) -> G2Element:
 async def make_and_send_spend_bundle(
     sim: SpendSim,
     sim_client: SimClient,
-    coin_spends: List[CoinSpend],
+    coin_spends: list[CoinSpend],
     is_eligible_for_ff: bool = True,
     *,
     is_launcher_coin: bool = False,
     signing_puzzle: Optional[Program] = None,
     signing_coin: Optional[Coin] = None,
     aggsig: G2Element = G2Element(),
-) -> Tuple[MempoolInclusionStatus, Optional[Err]]:
+) -> tuple[MempoolInclusionStatus, Optional[Err]]:
     if is_launcher_coin or not is_eligible_for_ff:
         assert signing_puzzle is not None
         assert signing_coin is not None
@@ -268,7 +268,7 @@ async def make_and_send_spend_bundle(
     return status, error
 
 
-async def get_singleton_and_remaining_coins(sim: SpendSim) -> Tuple[Coin, List[Coin]]:
+async def get_singleton_and_remaining_coins(sim: SpendSim) -> tuple[Coin, list[Coin]]:
     coins = await sim.all_non_reward_coins()
     singletons = [coin for coin in coins if coin.amount & 1]
     assert len(singletons) == 1
@@ -281,9 +281,9 @@ def make_singleton_coin_spend(
     parent_coin_spend: CoinSpend,
     coin_to_spend: Coin,
     inner_puzzle: Program,
-    inner_conditions: List[List[Any]],
+    inner_conditions: list[list[Any]],
     is_eve_spend: bool = False,
-) -> Tuple[CoinSpend, Program]:
+) -> tuple[CoinSpend, Program]:
     lineage_proof = singleton_top_layer.lineage_proof_for_coinsol(parent_coin_spend)
     delegated_puzzle = Program.to((1, inner_conditions))
     inner_solution = Program.to([[], delegated_puzzle, []])
@@ -300,7 +300,7 @@ def make_singleton_coin_spend(
 
 async def prepare_singleton_eve(
     sim: SpendSim, sim_client: SimClient, is_eligible_for_ff: bool, start_amount: uint64, singleton_amount: uint64
-) -> Tuple[Program, CoinSpend, Program]:
+) -> tuple[Program, CoinSpend, Program]:
     # Generate starting info
     key_lookup = KeyTool()
     pk = G1Element.from_bytes(public_key_for_index(1, key_lookup))
@@ -350,7 +350,7 @@ async def prepare_singleton_eve(
 
 async def prepare_and_test_singleton(
     sim: SpendSim, sim_client: SimClient, is_eligible_for_ff: bool, start_amount: uint64, singleton_amount: uint64
-) -> Tuple[Coin, CoinSpend, Program, Coin]:
+) -> tuple[Coin, CoinSpend, Program, Coin]:
     inner_puzzle, eve_coin_spend, eve_signing_puzzle = await prepare_singleton_eve(
         sim, sim_client, is_eligible_for_ff, start_amount, singleton_amount
     )
@@ -407,7 +407,7 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
         sk = AugSchemeMPL.key_gen(b"1" * 32)
         g1 = sk.get_g1()
         sig = AugSchemeMPL.sign(sk, b"foobar", g1)
-        inner_conditions: List[List[Any]] = [
+        inner_conditions: list[list[Any]] = [
             [ConditionOpcode.AGG_SIG_UNSAFE, bytes(g1), b"foobar"],
             [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_CHILD_AMOUNT],
         ]
@@ -501,7 +501,7 @@ async def test_singleton_fast_forward_same_block() -> None:
         sk = AugSchemeMPL.key_gen(b"9" * 32)
         g1 = sk.get_g1()
         sig = AugSchemeMPL.sign(sk, b"foobar", g1)
-        inner_conditions: List[List[Any]] = [
+        inner_conditions: list[list[Any]] = [
             [ConditionOpcode.AGG_SIG_UNSAFE, bytes(g1), b"foobar"],
             [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_CHILD_AMOUNT],
         ]