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

chia/_tests/core/test_cost_calculation.py

@@ -19,7 +19,7 @@ from chia.full_node.bundle_tools import simple_solution_generator
 from chia.full_node.mempool_check_conditions import get_puzzle_and_solution_for_coin
 from chia.simulator.block_tools import BlockTools, test_constants
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.program import Program, run_with_cost
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.generator_types import BlockGenerator
 from chia.wallet.puzzles import p2_delegated_puzzle_or_hidden_puzzle
@@ -171,7 +171,7 @@ async def test_mempool_mode(softfork_height: int, bt: BlockTools) -> None:
         uint64(300),
     )
     spend_info = get_puzzle_and_solution_for_coin(generator, coin, softfork_height, bt.constants)
-    assert spend_info.puzzle.to_program() == puzzle
+    assert spend_info.puzzle == puzzle.to_serialized()
 
 
 @pytest.mark.anyio
@@ -275,8 +275,8 @@ async def test_standard_tx(benchmark_runner: BenchmarkRunner) -> None:
 
     with benchmark_runner.assert_runtime(seconds=0.1):
         total_cost = 0
-        for i in range(0, 1000):
-            cost, _result = puzzle_program.run_with_cost(test_constants.MAX_BLOCK_COST_CLVM, solution_program)
+        for i in range(1000):
+            cost, _result = run_with_cost(puzzle_program, test_constants.MAX_BLOCK_COST_CLVM, solution_program)
             total_cost += cost
 
 
@@ -287,8 +287,8 @@ async def test_get_puzzle_and_solution_for_coin_performance(benchmark_runner: Be
 
     assert LARGE_BLOCK.transactions_generator is not None
     # first, list all spent coins in the block
-    _, result = LARGE_BLOCK.transactions_generator.run_with_cost(
-        DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM, [DESERIALIZE_MOD, []]
+    _, result = run_with_cost(
+        LARGE_BLOCK.transactions_generator, DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM, [DESERIALIZE_MOD, []]
     )
 
     coin_spends = result.first()

chia/_tests/core/test_crawler.py

@@ -13,11 +13,11 @@ from chia._tests.util.setup_nodes import SimulatorsAndWalletsServices
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.protocols.full_node_protocol import NewPeak
+from chia.protocols.outbound_message import make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.wallet_protocol import RequestChildren
 from chia.seeder.peer_record import PeerRecord, PeerReliability
-from chia.server.outbound_message import make_msg
-from chia.types.aliases import CrawlerService
+from chia.server.aliases import CrawlerService
 from chia.types.peer_info import PeerInfo
 
 

chia/_tests/core/test_crawler_rpc.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import pytest
 
-from chia.rpc.crawler_rpc_api import CrawlerRpcApi
 from chia.seeder.crawler import Crawler
+from chia.seeder.crawler_rpc_api import CrawlerRpcApi
 
 
 @pytest.mark.anyio

chia/_tests/core/test_db_conversion.py

@@ -12,6 +12,7 @@ from chia.cmds.db_upgrade_func import convert_v1_to_v2
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.multiprocess_validation import PreValidationResult
+from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.hint_store import HintStore
@@ -67,7 +68,8 @@ async def test_blocks(default_1000_blocks, with_hints: bool):
                 for h in hints:
                     await hint_store1.add_hints([(h[0], h[1])])
 
-            bc = await Blockchain.create(coin_store1, block_store1, test_constants, Path("."), reserved_cores=0)
+            height_map = await BlockHeightMap.create(Path("."), db_wrapper1)
+            bc = await Blockchain.create(coin_store1, block_store1, height_map, test_constants, reserved_cores=0)
             sub_slot_iters = test_constants.SUB_SLOT_ITERS_STARTING
             for block in blocks:
                 if block.height != 0 and len(block.finished_sub_slots) > 0:

chia/_tests/core/test_db_validation.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import Any
 
 import pytest
+from chia_rs import FullBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
@@ -16,10 +17,10 @@ from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.multiprocess_validation import PreValidationResult
+from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.simulator.block_tools import test_constants
-from chia.types.full_block import FullBlock
 from chia.util.db_wrapper import DBWrapper2
 
 
@@ -116,7 +117,7 @@ def test_db_validate_in_main_chain(invalid_in_chain: bool, default_config: dict[
             make_block_table(conn)
 
             prev = bytes32(DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA)
-            for height in range(0, 100):
+            for height in range(100):
                 header_hash = rand_hash()
                 add_block(conn, header_hash, prev, height, True)
                 if height % 4 == 0:
@@ -143,8 +144,9 @@ async def make_db(db_file: Path, blocks: list[FullBlock]) -> None:
 
         block_store = await BlockStore.create(db_wrapper)
         coin_store = await CoinStore.create(db_wrapper)
+        height_map = await BlockHeightMap.create(Path("."), db_wrapper)
 
-        bc = await Blockchain.create(coin_store, block_store, test_constants, Path("."), reserved_cores=0)
+        bc = await Blockchain.create(coin_store, block_store, height_map, test_constants, reserved_cores=0)
         sub_slot_iters = test_constants.SUB_SLOT_ITERS_STARTING
         for block in blocks:
             if block.height != 0 and len(block.finished_sub_slots) > 0:

chia/_tests/core/test_farmer_harvester_rpc.py

@@ -21,25 +21,25 @@ from chia._tests.plot_sync.test_delta import dummy_plot
 from chia._tests.util.misc import assert_rpc_error
 from chia._tests.util.rpc import validate_get_routes
 from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_custom_interval
-from chia.consensus.coinbase import create_puzzlehash_for_pk
 from chia.farmer.farmer import Farmer
-from chia.plot_sync.receiver import Receiver, get_list_or_len
-from chia.plotting.util import add_plot_directory
-from chia.protocols import farmer_protocol
-from chia.protocols.harvester_protocol import Plot
-from chia.rpc.farmer_rpc_api import (
+from chia.farmer.farmer_rpc_api import (
     FilterItem,
     PaginatedRequestData,
     PlotInfoRequestData,
     PlotPathRequestData,
     plot_matches_filter,
 )
-from chia.rpc.farmer_rpc_client import FarmerRpcClient
+from chia.farmer.farmer_rpc_client import FarmerRpcClient
+from chia.plot_sync.receiver import Receiver, get_list_or_len
+from chia.plotting.util import add_plot_directory
+from chia.protocols import farmer_protocol
+from chia.protocols.harvester_protocol import Plot
 from chia.simulator.block_tools import get_plot_dir
 from chia.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
 from chia.util.config import load_config, lock_and_load_config, save_config
 from chia.util.hash import std_hash
 from chia.wallet.derive_keys import master_sk_to_wallet_sk, master_sk_to_wallet_sk_unhardened
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 
 log = logging.getLogger(__name__)
 
@@ -131,7 +131,7 @@ async def test_farmer_signage_point_endpoints(harvester_farmer_environment: Harv
         return len(await farmer_rpc_client.get_signage_points()) > 0
 
     sp = farmer_protocol.NewSignagePoint(
-        std_hash(b"1"), std_hash(b"2"), std_hash(b"3"), uint64(1), uint64(1000000), uint8(2), uint32(1)
+        std_hash(b"1"), std_hash(b"2"), std_hash(b"3"), uint64(1), uint64(1000000), uint8(2), uint32(1), uint32(0)
     )
     await farmer_api.new_signage_point(sp)
 
@@ -150,8 +150,8 @@ async def test_farmer_reward_target_endpoints(harvester_farmer_environment: Harv
     targets_2 = await farmer_rpc_client.get_reward_targets(True, 2)
     assert targets_2["have_pool_sk"] and targets_2["have_farmer_sk"]
 
-    new_ph: bytes32 = create_puzzlehash_for_pk(master_sk_to_wallet_sk(bt.farmer_master_sk, uint32(2)).get_g1())
-    new_ph_2: bytes32 = create_puzzlehash_for_pk(master_sk_to_wallet_sk(bt.pool_master_sk, uint32(7)).get_g1())
+    new_ph: bytes32 = puzzle_hash_for_pk(master_sk_to_wallet_sk(bt.farmer_master_sk, uint32(2)).get_g1())
+    new_ph_2: bytes32 = puzzle_hash_for_pk(master_sk_to_wallet_sk(bt.pool_master_sk, uint32(7)).get_g1())
 
     await farmer_rpc_client.set_reward_targets(encode_puzzle_hash(new_ph, "xch"), encode_puzzle_hash(new_ph_2, "xch"))
     targets_3 = await farmer_rpc_client.get_reward_targets(True, 10)
@@ -164,10 +164,10 @@ async def test_farmer_reward_target_endpoints(harvester_farmer_environment: Harv
     assert not targets_4["have_pool_sk"] and targets_4["have_farmer_sk"]
 
     # check observer addresses
-    observer_farmer: bytes32 = create_puzzlehash_for_pk(
+    observer_farmer: bytes32 = puzzle_hash_for_pk(
         master_sk_to_wallet_sk_unhardened(bt.farmer_master_sk, uint32(2)).get_g1()
     )
-    observer_pool: bytes32 = create_puzzlehash_for_pk(
+    observer_pool: bytes32 = puzzle_hash_for_pk(
         master_sk_to_wallet_sk_unhardened(bt.pool_master_sk, uint32(7)).get_g1()
     )
     await farmer_rpc_client.set_reward_targets(
@@ -241,7 +241,7 @@ async def test_farmer_get_pool_state(
             pool_dict[key].insert(0, before_24h)
 
     sp = farmer_protocol.NewSignagePoint(
-        std_hash(b"1"), std_hash(b"2"), std_hash(b"3"), uint64(1), uint64(1000000), uint8(2), uint32(1)
+        std_hash(b"1"), std_hash(b"2"), std_hash(b"3"), uint64(1), uint64(1000000), uint8(2), uint32(1), uint32(0)
     )
     await farmer_api.new_signage_point(sp)
     client_pool_state = await farmer_rpc_client.get_pool_state()
@@ -397,7 +397,7 @@ async def test_farmer_get_harvester_plots_endpoints(
         plots = harvester_plots
     elif endpoint == FarmerRpcClient.get_harvester_plots_invalid:
         invalid_paths = add_plot_directories("invalid", 3)
-        for dir_index, r in [(0, range(0, 6)), (1, range(6, 8)), (2, range(8, 13))]:
+        for dir_index, r in [(0, range(6)), (1, range(6, 8)), (2, range(8, 13))]:
             plots += [str(invalid_paths[dir_index] / f"{i}.plot") for i in r]
         for plot in plots:
             with open(plot, "w"):
@@ -412,7 +412,7 @@ async def test_farmer_get_harvester_plots_endpoints(
 
     elif endpoint == FarmerRpcClient.get_harvester_plots_duplicates:
         duplicate_paths = add_plot_directories("duplicates", 2)
-        for dir_index, r in [(0, range(0, 3)), (1, range(3, 7))]:
+        for dir_index, r in [(0, range(3)), (1, range(3, 7))]:
             for i in r:
                 plot_path = Path(harvester_plots[i]["filename"])
                 plots.append(str(duplicate_paths[dir_index] / plot_path.name))

chia/_tests/core/test_filter.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import pytest
 from chiabip158 import PyBIP158
 
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
+
 
 @pytest.mark.anyio
 async def test_basic_filter_test(simulator_and_wallet):
@@ -11,7 +13,8 @@ async def test_basic_filter_test(simulator_and_wallet):
     wallet = wallet_node.wallet_state_manager.main_wallet
 
     num_blocks = 2
-    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)
     blocks = bt.get_consecutive_blocks(
         10,
         guarantee_transaction_block=True,