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

chia/_tests/fee_estimation/test_fee_estimation_rpc.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import Any, List, Tuple
+from typing import Any
 
 import pytest
 
@@ -21,8 +21,8 @@ from chia.util.ints import uint64
 
 @pytest.fixture(scope="function")
 async def setup_node_and_rpc(
-    two_wallet_nodes_services: Tuple[List[SimulatorFullNodeService], List[WalletService], BlockTools],
-) -> Tuple[FullNodeRpcClient, FullNodeRpcApi]:
+    two_wallet_nodes_services: tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools],
+) -> tuple[FullNodeRpcClient, FullNodeRpcApi]:
     full_nodes, wallets, bt = two_wallet_nodes_services
     wallet = wallets[0]._node.wallet_state_manager.main_wallet
     full_node_apis = [full_node_service._api for full_node_service in full_nodes]
@@ -47,9 +47,9 @@ async def setup_node_and_rpc(
 
 @pytest.fixture(scope="function")
 async def one_node_no_blocks(
-    one_node: Tuple[List[SimulatorFullNodeService], List[WalletService], BlockTools]
-) -> Tuple[FullNodeRpcClient, FullNodeRpcApi]:
-    full_nodes, wallets, bt = one_node
+    one_node: tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools],
+) -> tuple[FullNodeRpcClient, FullNodeRpcApi]:
+    full_nodes, _wallets, bt = one_node
     full_node_apis = [full_node_service._api for full_node_service in full_nodes]
     full_node_api: FullNodeSimulator = full_node_apis[0]
     full_node_service_1 = full_nodes[0]
@@ -66,7 +66,7 @@ async def one_node_no_blocks(
 
 
 @pytest.mark.anyio
-async def test_get_blockchain_state(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+async def test_get_blockchain_state(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
     # Confirm full node setup correctly
     client, _ = setup_node_and_rpc
     response = await client.get_blockchain_state()
@@ -74,16 +74,16 @@ async def test_get_blockchain_state(setup_node_and_rpc: Tuple[FullNodeRpcClient,
 
 
 @pytest.mark.anyio
-async def test_empty_request(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_empty_request(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
 
     with pytest.raises(ValueError):
         await full_node_rpc_api.get_fee_estimate({})
 
 
 @pytest.mark.anyio
-async def test_empty_peak(one_node_no_blocks: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = one_node_no_blocks
+async def test_empty_peak(one_node_no_blocks: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = one_node_no_blocks
     response = await full_node_rpc_api.get_fee_estimate({"target_times": [], "cost": 1})
     del response["node_time_utc"]
     assert response == {
@@ -105,57 +105,57 @@ async def test_empty_peak(one_node_no_blocks: Tuple[FullNodeRpcClient, FullNodeR
 
 
 @pytest.mark.anyio
-async def test_no_target_times(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_no_target_times(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     with pytest.raises(ValueError):
         await full_node_rpc_api.get_fee_estimate({"cost": 1})
 
 
 @pytest.mark.anyio
-async def test_negative_time(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_negative_time(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     with pytest.raises(ValueError):
         await full_node_rpc_api.get_fee_estimate({"cost": 1, "target_times": [-1]})
 
 
 @pytest.mark.anyio
-async def test_negative_cost(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_negative_cost(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     with pytest.raises(ValueError):
         await full_node_rpc_api.get_fee_estimate({"cost": -1, "target_times": [1]})
 
 
 @pytest.mark.anyio
-async def test_no_cost_or_tx(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_no_cost_or_tx(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     with pytest.raises(ValueError):
         await full_node_rpc_api.get_fee_estimate({"target_times": []})
 
 
 @pytest.mark.anyio
-async def test_both_cost_and_tx(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_both_cost_and_tx(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     with pytest.raises(ValueError):
         await full_node_rpc_api.get_fee_estimate({"target_times": [], "cost": 1, "spend_bundle": "80"})
 
 
 @pytest.mark.anyio
-async def test_target_times_invalid_type(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_target_times_invalid_type(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     with pytest.raises(TypeError):
         await full_node_rpc_api.get_fee_estimate({"target_times": 1, "cost": 1})
 
 
 @pytest.mark.anyio
-async def test_cost_invalid_type(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_cost_invalid_type(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     with pytest.raises(ValueError):
         await full_node_rpc_api.get_fee_estimate({"target_times": [], "cost": "a lot"})
 
 
 @pytest.mark.anyio
-async def test_tx_invalid_type(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_tx_invalid_type(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     with pytest.raises(TypeError):
         await full_node_rpc_api.get_fee_estimate({"target_times": [], "spend_bundle": {"coin_spends": 1}})
 
@@ -164,24 +164,24 @@ async def test_tx_invalid_type(setup_node_and_rpc: Tuple[FullNodeRpcClient, Full
 
 
 @pytest.mark.anyio
-async def test_empty_target_times(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_empty_target_times(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     response = await full_node_rpc_api.get_fee_estimate({"target_times": [], "cost": 1})
     assert response["estimates"] == []
     assert response["target_times"] == []
 
 
 @pytest.mark.anyio
-async def test_cost(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_cost(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     response = await full_node_rpc_api.get_fee_estimate({"target_times": [1], "cost": 1})
     assert response["estimates"] == [0]
     assert response["target_times"] == [1]
 
 
 @pytest.mark.anyio
-async def test_tx(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_tx(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     wallet_a: WalletTool = bt.get_pool_wallet_tool()
     my_puzzle_hash = wallet_a.get_new_puzzlehash()
     recevier_puzzle_hash = bytes32(b"0" * 32)
@@ -197,8 +197,8 @@ async def test_tx(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi],
 
 
 @pytest.mark.anyio
-async def test_multiple(setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+async def test_multiple(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
     response = await full_node_rpc_api.get_fee_estimate({"target_times": [1, 5, 10, 15, 60, 120, 180, 240], "cost": 1})
     assert response["estimates"] == [0, 0, 0, 0, 0, 0, 0, 0]
     assert response["target_times"] == [1, 5, 10, 15, 60, 120, 180, 240]
@@ -214,11 +214,11 @@ def get_test_spendbundle(bt: BlockTools) -> SpendBundle:
 
 @pytest.mark.anyio
 async def test_validate_fee_estimate_cost_err(
-    setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
+    setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
 ) -> None:
     spend_bundle = get_test_spendbundle(bt)
-    client, full_node_rpc_api = setup_node_and_rpc
-    bad_arglist: List[List[Any]] = [
+    _client, full_node_rpc_api = setup_node_and_rpc
+    bad_arglist: list[list[Any]] = [
         [["foo", "bar"]],
         [["spend_bundle", spend_bundle.to_json_dict()], ["cost", 1]],
         [["spend_bundle", spend_bundle.to_json_dict()], ["spend_type", "send_xch_transaction"]],
@@ -239,12 +239,12 @@ async def test_validate_fee_estimate_cost_err(
 
 @pytest.mark.anyio
 async def test_validate_fee_estimate_cost_ok(
-    setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
+    setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
 ) -> None:
     spend_bundle = get_test_spendbundle(bt)
-    client, full_node_rpc_api = setup_node_and_rpc
+    _client, full_node_rpc_api = setup_node_and_rpc
 
-    good_arglist: List[List[Any]] = [
+    good_arglist: list[list[Any]] = [
         ["spend_bundle", spend_bundle.to_json_dict()],
         ["cost", 1],
         ["spend_type", "send_xch_transaction"],
@@ -257,9 +257,9 @@ async def test_validate_fee_estimate_cost_ok(
 
 @pytest.mark.anyio
 async def test_get_spendbundle_type_cost_missing(
-    setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
+    setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
 ) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+    _client, full_node_rpc_api = setup_node_and_rpc
     with pytest.raises(KeyError, match=re.escape("INVALID")):
         request = {"target_times": [1], "spend_type": "INVALID"}
         _ = await full_node_rpc_api.get_fee_estimate(request)
@@ -267,9 +267,9 @@ async def test_get_spendbundle_type_cost_missing(
 
 @pytest.mark.anyio
 async def test_get_spendbundle_type_cost_spend_count_ok(
-    setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
+    setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
 ) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+    _client, full_node_rpc_api = setup_node_and_rpc
     spend_counts = [0, 1, 2]
     for spend_count in spend_counts:
         request = {"target_times": [1], "spend_type": "send_xch_transaction", "spend_count": spend_count}
@@ -279,9 +279,9 @@ async def test_get_spendbundle_type_cost_spend_count_ok(
 
 @pytest.mark.anyio
 async def test_get_spendbundle_type_cost_spend_count_bad(
-    setup_node_and_rpc: Tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
+    setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
 ) -> None:
-    client, full_node_rpc_api = setup_node_and_rpc
+    _client, full_node_rpc_api = setup_node_and_rpc
     with pytest.raises(ValueError):
         request = {"target_times": [1], "spend_type": "send_xch_transaction", "spend_count": -1}
         _ = await full_node_rpc_api.get_fee_estimate(request)

chia/_tests/fee_estimation/test_fee_estimation_unit_tests.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import List
 
 import pytest
 
@@ -47,7 +46,7 @@ def test_single_estimate() -> None:
 
 def make_block(
     height: uint32, num_tx: int, cost: uint64, fee: uint64, num_blocks_wait_in_mempool: int
-) -> List[MempoolItemInfo]:
+) -> list[MempoolItemInfo]:
     block_included = uint32(height - num_blocks_wait_in_mempool)
     return [MempoolItemInfo(cost, fee, block_included)] * num_tx
 
@@ -95,7 +94,7 @@ def test_init_buckets() -> None:
 
 
 def test_get_bucket_index_empty_buckets() -> None:
-    buckets: List[float] = []
+    buckets: list[float] = []
     for rate in [0.5, 1.0, 2.0]:
         with pytest.raises(RuntimeError):
             a = get_bucket_index(buckets, rate)
@@ -134,12 +133,12 @@ def test_get_bucket_index() -> None:
 
 
 def test_monotonically_decrease() -> None:
-    inputs: List[List[float]]
-    output: List[List[float]]
+    inputs: list[list[float]]
+    output: list[list[float]]
     inputs = [[], [-1], [0], [1], [0, 0], [0, 1], [1, 0], [1, 2, 3], [1, 1, 1], [3, 2, 1], [3, 3, 1], [1, 3, 3]]
     output = [[], [-1], [0], [1], [0, 0], [0, 0], [1, 0], [1, 1, 1], [1, 1, 1], [3, 2, 1], [3, 3, 1], [1, 1, 1]]
-    i: List[float]
-    o: List[float]
+    i: list[float]
+    o: list[float]
     for i, o in zip(inputs, output):
         print(o, i)
         assert o == make_monotonically_decreasing(i)

chia/_tests/fee_estimation/test_mempoolitem_height_added.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 import logging
-from typing import Callable, List, Optional, Tuple
+from typing import Callable, Optional
 
 import pytest
 from chia_rs import Coin, G2Element
 
-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.constants import ConsensusConstants
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bitcoin_fee_estimator import BitcoinFeeEstimator
@@ -32,7 +32,7 @@ async def farm(
     sim: SpendSim,
     puzzle_hash: bytes32,
     item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
-) -> Tuple[List[Coin], List[Coin], List[Coin]]:
+) -> tuple[list[Coin], list[Coin], list[Coin]]:
     additions, removals = await sim.farm_block(puzzle_hash)  # , item_inclusion_filter)
     height = sim.get_height()
     new_reward_coins = sim.block_records[height].reward_claims_incorporated
@@ -51,7 +51,7 @@ def make_tx_sb(from_coin: Coin) -> SpendBundle:
 
 async def init_test(
     sim: SpendSim, cli: SimClient, puzzle_hash: bytes32, spends_per_block: int
-) -> Tuple[BitcoinFeeEstimator, List[Coin], List[Coin]]:
+) -> tuple[BitcoinFeeEstimator, list[Coin], list[Coin]]:
     new_reward_coins = []
     spend_coins = []
     fee_coins = []
@@ -79,11 +79,11 @@ async def init_test(
 @pytest.mark.anyio
 async def test_mempool_inclusion_filter_basic() -> None:
     async with sim_and_client(defaults=NEW_DEFAULT_CONSTANTS, pass_prefarm=False) as (sim, cli):
-        estimator, spend_coins, fee_coins = await init_test(sim, cli, the_puzzle_hash, 1)
+        _estimator, spend_coins, _fee_coins = await init_test(sim, cli, the_puzzle_hash, 1)
         assert sim.mempool_manager.mempool.size() == 0
 
         spend_bundle: SpendBundle = make_tx_sb(spend_coins[0])
-        status, error = await cli.push_tx(spend_bundle)
+        _status, error = await cli.push_tx(spend_bundle)
         assert sim.mempool_manager.mempool.size() == 1
         assert error is None
 
@@ -96,11 +96,11 @@ async def test_mempool_inclusion_filter_basic() -> None:
         def include_all(bundle_name: bytes32) -> bool:
             return True
 
-        additions, removals = await sim.farm_block(the_puzzle_hash, item_inclusion_filter=include_none)
+        _additions, removals = await sim.farm_block(the_puzzle_hash, item_inclusion_filter=include_none)
         assert sim.mempool_manager.mempool.size() == 1
         assert removals == []
 
-        additions, removals = await sim.farm_block(the_puzzle_hash, item_inclusion_filter=include_all)
+        _additions, removals = await sim.farm_block(the_puzzle_hash, item_inclusion_filter=include_all)
         assert sim.mempool_manager.mempool.size() == 0
         removal_ids = [c.name() for c in removals]
         assert mempool_item.name not in removal_ids
@@ -109,7 +109,7 @@ async def test_mempool_inclusion_filter_basic() -> None:
 @pytest.mark.anyio
 async def test_mempoolitem_height_added(db_version: int) -> None:
     async with sim_and_client(defaults=NEW_DEFAULT_CONSTANTS, pass_prefarm=False) as (sim, cli):
-        estimator, spend_coins, fee_coins = await init_test(sim, cli, the_puzzle_hash, 1)
+        _estimator, spend_coins, _fee_coins = await init_test(sim, cli, the_puzzle_hash, 1)
         assert sim.mempool_manager.mempool.size() == 0
 
         spend_bundle: SpendBundle = make_tx_sb(spend_coins[0])
@@ -126,7 +126,7 @@ async def test_mempoolitem_height_added(db_version: int) -> None:
             assert mempool_item
             return bundle_name != mempool_item.name
 
-        additions, removals = await sim.farm_block(the_puzzle_hash, item_inclusion_filter=ignore_spend)
+        _additions, removals = await sim.farm_block(the_puzzle_hash, item_inclusion_filter=ignore_spend)
         removal_ids = [c.name() for c in removals]
         assert mempool_item.name not in removal_ids
 
@@ -139,7 +139,7 @@ async def test_mempoolitem_height_added(db_version: int) -> None:
         assert mempool_item2.height_added_to_mempool == mempool_item2.height_added_to_mempool
 
         # Now farm it into the next block
-        additions, removals = await sim.farm_block(the_puzzle_hash)
+        _additions, removals = await sim.farm_block(the_puzzle_hash)
         assert sim.mempool_manager.mempool.size() == 0
         assert len(removals) == 1
 

chia/_tests/generator/test_compression.py

@@ -1,24 +1,15 @@
-# flake8: noqa: F501
+# ruff: noqa: E501
 from __future__ import annotations
 
 import io
-from dataclasses import dataclass
-from typing import Any, List
+from typing import Any
 
-import pytest
-from chia_rs import ALLOW_BACKREFS
+from chia_rs import serialized_length
 from clvm.serialize import sexp_from_stream
 from clvm.SExp import SExp
 from clvm_tools import binutils
 
-from chia._tests.core.make_block_generator import make_spend_bundle
-from chia._tests.generator.test_rom import run_generator
-from chia.full_node.bundle_tools import simple_solution_generator, simple_solution_generator_backrefs
-from chia.full_node.mempool_check_conditions import get_puzzle_and_solution_for_coin
-from chia.simulator.block_tools import test_constants
 from chia.types.blockchain_format.program import INFINITE_COST, Program
-from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.generator_types import BlockGenerator
 from chia.types.spend_bundle import SpendBundle
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.ints import uint32
@@ -44,21 +35,19 @@ Nil = Program.from_bytes(b"\x80")
 
 original_generator = hexstr_to_bytes(
     "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"
-)  # noqa
+)
 
 gen1 = b"\xff\x01" + original_generator
 gen2 = b"\xff\x01\xff\x01" + original_generator
 FAKE_BLOCK_HEIGHT1 = uint32(100)
 FAKE_BLOCK_HEIGHT2 = uint32(200)
 
-from chia_rs import serialized_length
-
 assert serialized_length(original_generator) == len(original_generator)
 assert serialized_length(gen1) == len(gen1)
 assert serialized_length(gen2) == len(gen2)
 
 
-def spend_bundle_to_coin_spend_entry_list(bundle: SpendBundle) -> List[Any]:
+def spend_bundle_to_coin_spend_entry_list(bundle: SpendBundle) -> list[Any]:
     r = []
     for coin_spend in bundle.coin_spends:
         entry = [
@@ -78,11 +67,11 @@ class TestCompression:
 
 class TestDecompression:
     def test_deserialization(self) -> None:
-        cost, out = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [bytes(Program.to("hello"))])
+        _cost, out = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [bytes(Program.to("hello"))])
         assert out == Program.to("hello")
 
     def test_deserialization_as_argument(self) -> None:
-        cost, out = TEST_GEN_DESERIALIZE.run_with_cost(
+        _cost, out = TEST_GEN_DESERIALIZE.run_with_cost(
             INFINITE_COST, [DESERIALIZE_MOD, Nil, bytes(Program.to("hello"))]
         )
         print(bytes(Program.to("hello")))
@@ -91,7 +80,7 @@ class TestDecompression:
         assert out == Program.to("hello")
 
     def test_decompress_puzzle(self) -> None:
-        cost, out = DECOMPRESS_PUZZLE.run_with_cost(
+        _cost, out = DECOMPRESS_PUZZLE.run_with_cost(
             INFINITE_COST, [DESERIALIZE_MOD, b"\xff", bytes(Program.to("pubkey")), b"\x80"]
         )
 
@@ -110,7 +99,7 @@ class TestDecompression:
         cse0 = binutils.assemble(
             "((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0) (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3 (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ())))"
         )
-        cost, out = DECOMPRESS_CSE.run_with_cost(
+        _cost, out = DECOMPRESS_CSE.run_with_cost(
             INFINITE_COST, [DESERIALIZE_MOD, DECOMPRESS_PUZZLE, b"\xff", b"\x80", cse0]
         )
 
@@ -126,7 +115,7 @@ class TestDecompression:
         end = start + 238
         prefix = original_generator[start:end]
         # (deserialize decompress_puzzle puzzle_prefix cse)
-        cost, out = DECOMPRESS_CSE_WITH_PREFIX.run_with_cost(
+        _cost, out = DECOMPRESS_CSE_WITH_PREFIX.run_with_cost(
             INFINITE_COST, [DESERIALIZE_MOD, DECOMPRESS_PUZZLE, prefix, cse0]
         )
 
@@ -135,9 +124,6 @@ class TestDecompression:
 
     def test_block_program_zero(self) -> None:
         "Decompress a list of CSEs"
-        cse1 = binutils.assemble(
-            "(((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0) (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3 (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ()))))"
-        )
         cse2 = binutils.assemble(
             """
 (
@@ -159,7 +145,7 @@ class TestDecompression:
 
         # (mod (decompress_puzzle decompress_coin_spend_entry start end compressed_cses deserialize generator_list reserved_arg)
         # cost, out = DECOMPRESS_BLOCK.run_with_cost(INFINITE_COST, [DECOMPRESS_PUZZLE, DECOMPRESS_CSE, start, Program.to(end), cse0, DESERIALIZE_MOD, bytes(original_generator)])
-        cost, out = DECOMPRESS_BLOCK.run_with_cost(
+        _cost, out = DECOMPRESS_BLOCK.run_with_cost(
             INFINITE_COST,
             [
                 DECOMPRESS_PUZZLE,
@@ -176,9 +162,6 @@ class TestDecompression:
         print(out)
 
     def test_block_program_zero_with_curry(self) -> None:
-        cse1 = binutils.assemble(
-            "(((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0) (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3 (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ()))))"
-        )
         cse2 = binutils.assemble(
             """
 (
@@ -201,7 +184,7 @@ class TestDecompression:
         # (mod (decompress_puzzle decompress_coin_spend_entry start end compressed_cses deserialize generator_list reserved_arg)
         # cost, out = DECOMPRESS_BLOCK.run_with_cost(INFINITE_COST, [DECOMPRESS_PUZZLE, DECOMPRESS_CSE, start, Program.to(end), cse0, DESERIALIZE_MOD, bytes(original_generator)])
         p = DECOMPRESS_BLOCK.curry(DECOMPRESS_PUZZLE, DECOMPRESS_CSE_WITH_PREFIX, start, Program.to(end))
-        cost, out = p.run_with_cost(INFINITE_COST, [cse2, DESERIALIZE_MOD, [bytes(original_generator)]])
+        _cost, out = p.run_with_cost(INFINITE_COST, [cse2, DESERIALIZE_MOD, [bytes(original_generator)]])
 
         print()
         print(p)
@@ -211,7 +194,7 @@ class TestDecompression:
             DECOMPRESS_PUZZLE, DECOMPRESS_CSE_WITH_PREFIX, start, Program.to(end), cse2, DESERIALIZE_MOD
         )
         generator_args = Program.to([[original_generator]])
-        cost, out = p_with_cses.run_with_cost(INFINITE_COST, generator_args)
+        _cost, out = p_with_cses.run_with_cost(INFINITE_COST, generator_args)
 
         print()
         print(p_with_cses)

chia/_tests/generator/test_generator_types.py

@@ -7,19 +7,19 @@ from chia.types.blockchain_format.serialized_program import SerializedProgram
 
 gen0 = SerializedProgram.from_bytes(
     bytes.fromhex(
-        "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"  # noqa
+        "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"
     )
 )
 
 gen1 = SerializedProgram.from_bytes(
     bytes.fromhex(
-        "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"  # noqa
+        "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"
     )
 )
 
 gen2 = SerializedProgram.from_bytes(
     bytes.fromhex(
-        "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"  # noqa
+        "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"
     )
 )
 

chia/_tests/generator/test_rom.py

@@ -1,14 +1,12 @@
 from __future__ import annotations
 
-from typing import List, Tuple
-
 from clvm.CLVMObject import CLVMStorage
 from clvm_tools import binutils
 from clvm_tools.clvmc import compile_clvm_text
 
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia.consensus.condition_costs import ConditionCost
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -17,8 +15,8 @@ from chia.types.spend_bundle_conditions import SpendConditions
 from chia.util.ints import uint32
 from chia.wallet.puzzles.load_clvm import load_clvm, load_serialized_clvm_maybe_recompile
 
-MAX_COST = int(1e15)
-COST_PER_BYTE = int(12000)
+MAX_COST = 10**15
+COST_PER_BYTE = 12000
 
 
 DESERIALIZE_MOD = load_clvm("chialisp_deserialisation.clsp", package_or_requirement="chia.consensus.puzzles")
@@ -78,13 +76,13 @@ EXPECTED_OUTPUT = (
 )
 
 
-def run_generator(self: BlockGenerator) -> Tuple[int, Program]:
+def run_generator(self: BlockGenerator) -> tuple[int, Program]:
     """This mode is meant for accepting possibly soft-forked transactions into the mempool"""
     args = Program.to([self.generator_refs])
     return GENERATOR_MOD.run_with_cost(MAX_COST, [self.program, args])
 
 
-def as_atom_list(prg: CLVMStorage) -> List[bytes]:
+def as_atom_list(prg: CLVMStorage) -> list[bytes]:
     """
     Pretend `prg` is a list of atoms. Return the corresponding
     python list of atoms.
@@ -167,7 +165,7 @@ class TestROM:
         # the ROM supports extra data after a coin. This test checks that it actually gets passed through
 
         gen = block_generator()
-        cost, r = run_generator(gen)
+        _cost, r = run_generator(gen)
         coin_spends = r.first()
         for coin_spend in coin_spends.as_iter():
             extra_data = coin_spend.rest().rest().rest().rest()
@@ -177,6 +175,6 @@ class TestROM:
         # the ROM supports extra data after the coin spend list. This test checks that it actually gets passed through
 
         gen = block_generator()
-        cost, r = run_generator(gen)
+        _cost, r = run_generator(gen)
         extra_block_data = r.rest()
         assert as_atom_list(extra_block_data) == b"extra data for block".split()

chia/_tests/plot_sync/test_delta.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import List
 
 import pytest
 from chia_rs import G1Element
@@ -79,13 +78,13 @@ def test_list_delta(delta: DeltaType) -> None:
         [["-2", "2", "3", "-1"], ["2", "3"], PathListDelta([], ["-2", "-1"])],
     ],
 )
-def test_path_list_delta_from_lists(old: List[str], new: List[str], result: PathListDelta) -> None:
+def test_path_list_delta_from_lists(old: list[str], new: list[str], result: PathListDelta) -> None:
     assert PathListDelta.from_lists(old, new) == result
 
 
 def test_delta_empty() -> None:
     delta: Delta = Delta()
-    all_deltas: List[DeltaType] = [delta.valid, delta.invalid, delta.keys_missing, delta.duplicates]
+    all_deltas: list[DeltaType] = [delta.valid, delta.invalid, delta.keys_missing, delta.duplicates]
     assert delta.empty()
     for d1 in all_deltas:
         delta.valid.additions["0"] = dummy_plot("0")