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

chia/_tests/util/benchmarks.py

@@ -10,9 +10,11 @@ from chia_rs import (
     Foliage,
     FoliageBlockData,
     FoliageTransactionBlock,
+    FullBlock,
     G1Element,
     G2Element,
     PoolTarget,
+    ProofOfSpace,
     RewardChainBlock,
     TransactionsInfo,
     VDFInfo,
@@ -23,9 +25,7 @@ from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.types.blockchain_format.proof_of_space import ProofOfSpace
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.full_block import FullBlock
 
 # farmer puzzle hash
 ph = bytes32(b"a" * 32)

chia/_tests/util/blockchain.py

@@ -2,18 +2,19 @@ from __future__ import annotations
 
 import contextlib
 import os
-import pickle
+import pickle  # noqa: S403  # TODO: use explicit serialization instead of pickle
 from collections.abc import AsyncIterator
 from pathlib import Path
 from typing import Optional
 
-from chia_rs import ConsensusConstants
+from chia_rs import ConsensusConstants, FullBlock
+from chia_rs.sized_ints import uint64
 
 from chia.consensus.blockchain import Blockchain
+from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.simulator.block_tools import BlockTools
-from chia.types.full_block import FullBlock
 from chia.util.db_wrapper import DBWrapper2, generate_in_memory_db_uri
 from chia.util.default_root import DEFAULT_ROOT_PATH
 
@@ -26,7 +27,9 @@ async def create_blockchain(
     async with DBWrapper2.managed(database=db_uri, uri=True, reader_count=1, db_version=db_version) as wrapper:
         coin_store = await CoinStore.create(wrapper)
         store = await BlockStore.create(wrapper)
-        bc1 = await Blockchain.create(coin_store, store, constants, Path("."), 2, single_threaded=True, log_coins=True)
+        path = Path(".")
+        height_map = await BlockHeightMap.create(path, wrapper)
+        bc1 = await Blockchain.create(coin_store, store, height_map, constants, 3, single_threaded=True, log_coins=True)
         try:
             assert bc1.get_peak() is None
             yield bc1, wrapper
@@ -67,12 +70,14 @@ def persistent_blocks(
         print(f"File found at: {file_path}")
         try:
             bytes_list = file_path.read_bytes()
-            block_bytes_list: list[bytes] = pickle.loads(bytes_list)
+            # TODO: use explicit serialization instead of pickle
+            block_bytes_list: list[bytes] = pickle.loads(bytes_list)  # noqa: S301
             blocks: list[FullBlock] = []
             for block_bytes in block_bytes_list:
                 blocks.append(FullBlock.from_bytes_unchecked(block_bytes))
             if len(blocks) == num_of_blocks + len(block_list_input):
                 print(f"\n loaded {file_path} with {len(blocks)} blocks")
+
                 return blocks
         except EOFError:
             print("\n error reading db file")
@@ -126,6 +131,7 @@ def new_test_db(
         normalized_to_identity_cc_ip=normalized_to_identity_cc_ip,
         dummy_block_references=dummy_block_references,
         include_transactions=include_transactions,
+        genesis_timestamp=uint64(1234567890),
     )
     block_bytes_list: list[bytes] = []
     for block in blocks:

chia/_tests/util/blockchain_mock.py

@@ -3,14 +3,11 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
-from chia_rs import SubEpochChallengeSegment, SubEpochSegments
+from chia_rs import BlockRecord, HeaderBlock, SubEpochChallengeSegment, SubEpochSegments, SubEpochSummary
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
-from chia.consensus.block_record import BlockRecord
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
 from chia.types.blockchain_format.vdf import VDFInfo
-from chia.types.header_block import HeaderBlock
 
 
 # implements BlockchainInterface

chia/_tests/util/coin_store.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from chia.consensus.coin_store_protocol import CoinStoreProtocol
+from chia.types.coin_record import CoinRecord
+from chia.util.db_wrapper import DBWrapper2
+
+
+async def add_coin_records_to_db(coin_store: CoinStoreProtocol, records: list[CoinRecord]) -> None:
+    if len(records) == 0:
+        return
+    db_wrapper = getattr(coin_store, "db_wrapper", None)
+    assert isinstance(db_wrapper, DBWrapper2), "CoinStore must use DBWrapper2"
+    async with db_wrapper.writer_maybe_transaction() as conn:
+        await conn.executemany(
+            "INSERT INTO coin_record VALUES(?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                (
+                    record.coin.name(),
+                    record.confirmed_block_index,
+                    record.spent_block_index,
+                    int(record.coinbase),
+                    record.coin.puzzle_hash,
+                    record.coin.parent_coin_info,
+                    record.coin.amount.stream_to_bytes(),
+                    record.timestamp,
+                )
+                for record in records
+            ),
+        )

chia/_tests/util/constants.py

@@ -1,21 +1,5 @@
 from __future__ import annotations
 
-from chia_rs.sized_ints import uint8, uint16, uint32, uint64, uint128
+from chia.simulator.block_tools import test_constants
 
-from chia.consensus.default_constants import DEFAULT_CONSTANTS
-
-test_constants = DEFAULT_CONSTANTS.replace(
-    MIN_PLOT_SIZE=uint8(18),
-    MIN_BLOCKS_PER_CHALLENGE_BLOCK=uint8(12),
-    DIFFICULTY_STARTING=uint64(2**9),
-    DISCRIMINANT_SIZE_BITS=uint16(16),
-    SUB_EPOCH_BLOCKS=uint32(170),
-    WEIGHT_PROOF_THRESHOLD=uint8(2),
-    WEIGHT_PROOF_RECENT_BLOCKS=uint32(380),
-    DIFFICULTY_CONSTANT_FACTOR=uint128(33554432),
-    NUM_SPS_SUB_SLOT=uint32(16),  # Must be a power of 2
-    MAX_SUB_SLOT_BLOCKS=uint32(50),
-    EPOCH_BLOCKS=uint32(340),
-    SUB_SLOT_ITERS_STARTING=uint64(2**10),  # Must be a multiple of 64
-    NUMBER_ZERO_BITS_PLOT_FILTER=uint8(1),  # H(plot signature of the challenge) must start with these many zeroes
-)
+__all__ = ["test_constants"]

chia/_tests/util/full_sync.py

@@ -12,24 +12,24 @@ from typing import Callable, Optional, cast
 
 import aiosqlite
 import zstd
+from chia_rs import FullBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16
 
 from chia._tests.util.constants import test_constants as TEST_CONSTANTS
 from chia.cmds.init_funcs import chia_init
+from chia.consensus.augmented_chain import AugmentedBlockchain
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
 from chia.full_node.full_node import FullNode
-from chia.server.outbound_message import Message, NodeType
+from chia.protocols.outbound_message import Message, NodeType
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import ConnectionCallback, WSChiaConnection
 from chia.simulator.block_tools import make_unfinished_block
-from chia.types.full_block import FullBlock
 from chia.types.peer_info import PeerInfo
 from chia.types.validation_state import ValidationState
-from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.config import load_config
 
 

chia/_tests/util/generator_tools_testing.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
-from chia_rs import ConsensusConstants
+from chia_rs import ConsensusConstants, FullBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
 from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.consensus.generator_tools import tx_removals_and_additions
 from chia.types.blockchain_format.coin import Coin
-from chia.types.full_block import FullBlock
 from chia.types.generator_types import BlockGenerator
-from chia.util.generator_tools import tx_removals_and_additions
 
 
 def run_and_get_removals_and_additions(

chia/_tests/util/key_tool.py

@@ -2,12 +2,11 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 
-from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, CoinSpend, G1Element, G2Element, PrivateKey
 
 from chia._tests.core.make_block_generator import GROUP_ORDER, int_to_public_key
+from chia.consensus.condition_tools import conditions_dict_for_solution, pkm_pairs_for_conditions_dict
 from chia.simulator.block_tools import test_constants
-from chia.types.coin_spend import CoinSpend
-from chia.util.condition_tools import conditions_dict_for_solution, pkm_pairs_for_conditions_dict
 
 
 @dataclass

chia/_tests/util/misc.py

@@ -31,6 +31,7 @@ from aiohttp import web
 from chia_rs import Coin
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint32, uint64
+from typing_extensions import Self
 
 import chia
 import chia._tests
@@ -38,9 +39,9 @@ from chia._tests import ether
 from chia._tests.core.data_layer.util import ChiaRoot
 from chia._tests.util.time_out_assert import DataTypeProtocol, caller_file_and_line
 from chia.full_node.mempool import Mempool
+from chia.protocols.outbound_message import Message
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.server.api_protocol import ApiMetadata, ApiProtocol
-from chia.server.outbound_message import Message
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.hash import std_hash
 from chia.util.network import WebServer
@@ -49,10 +50,10 @@ from chia.wallet.wallet_node import WalletNode
 
 
 class GcMode(enum.Enum):
-    nothing = enum.auto
-    precollect = enum.auto
-    disable = enum.auto
-    enable = enum.auto
+    nothing = enum.auto()
+    precollect = enum.auto()
+    disable = enum.auto()
+    enable = enum.auto()
 
 
 @contextlib.contextmanager
@@ -477,24 +478,25 @@ def create_logger(file: TextIO = sys.stdout) -> logging.Logger:
 
 
 def invariant_check_mempool(mempool: Mempool) -> None:
-    with mempool._db_conn as conn:
-        cursor = conn.execute("SELECT COALESCE(SUM(cost), 0), COALESCE(SUM(fee), 0) FROM tx")
-        val = cursor.fetchone()
-        assert (mempool._total_cost, mempool._total_fee) == val
-
-    with mempool._db_conn as conn:
-        cursor = conn.execute("SELECT coin_id, tx FROM spends")
-        for coin_id, item_id in cursor.fetchall():
-            item = mempool._items.get(item_id)
-            assert item is not None
-            # item is expected to contain a spend of coin_id, but it might be a
-            # fast-forward spend, in which case the dictionary won't help us,
-            # but we'll have to do a linear search
-            if coin_id in item.bundle_coin_spends:
-                assert item.bundle_coin_spends[coin_id].coin_spend.coin.name() == coin_id
-                continue
-
-            assert any(map(lambda i: i.latest_singleton_coin == coin_id, item.bundle_coin_spends.values()))
+    cursor = mempool._db_conn.execute("SELECT COALESCE(SUM(cost), 0), COALESCE(SUM(fee), 0) FROM tx")
+    val = cursor.fetchone()
+    assert (mempool._total_cost, mempool._total_fee) == val
+
+    cursor = mempool._db_conn.execute("SELECT coin_id, tx FROM spends")
+    for coin_id, item_id in cursor.fetchall():
+        item = mempool._items.get(item_id)
+        assert item is not None
+        # item is expected to contain a spend of coin_id, but it might be a
+        # fast-forward spend, in which case the dictionary won't help us,
+        # but we'll have to do a linear search
+        if coin_id in item.bundle_coin_spends:
+            assert item.bundle_coin_spends[coin_id].coin_spend.coin.name() == coin_id
+            continue
+
+        assert any(
+            i.latest_singleton_lineage is not None and i.latest_singleton_lineage.coin_id == coin_id
+            for i in item.bundle_coin_spends.values()
+        )
 
 
 async def wallet_height_at_least(wallet_node: WalletNode, h: uint32) -> bool:
@@ -612,37 +614,37 @@ T_ComparableEnum = TypeVar("T_ComparableEnum", bound="ComparableEnum")
 
 
 class ComparableEnum(Enum):
-    def __lt__(self: T_ComparableEnum, other: T_ComparableEnum) -> object:
+    def __lt__(self, other: Self) -> object:
         if self.__class__ is not other.__class__:
             return NotImplemented
 
         return self.value.__lt__(other.value)
 
-    def __le__(self: T_ComparableEnum, other: T_ComparableEnum) -> object:
+    def __le__(self, other: Self) -> object:
         if self.__class__ is not other.__class__:
             return NotImplemented
 
         return self.value.__le__(other.value)
 
-    def __eq__(self: T_ComparableEnum, other: object) -> bool:
+    def __eq__(self, other: object) -> bool:
         if self.__class__ is not other.__class__:
             return False
 
-        return cast(bool, self.value.__eq__(cast(T_ComparableEnum, other).value))
+        return cast(bool, self.value.__eq__(cast(Self, other).value))
 
-    def __ne__(self: T_ComparableEnum, other: object) -> bool:
+    def __ne__(self, other: object) -> bool:
         if self.__class__ is not other.__class__:
             return True
 
-        return cast(bool, self.value.__ne__(cast(T_ComparableEnum, other).value))
+        return cast(bool, self.value.__ne__(cast(Self, other).value))
 
-    def __gt__(self: T_ComparableEnum, other: T_ComparableEnum) -> object:
+    def __gt__(self, other: Self) -> object:
         if self.__class__ is not other.__class__:
             return NotImplemented
 
         return self.value.__gt__(other.value)
 
-    def __ge__(self: T_ComparableEnum, other: T_ComparableEnum) -> object:
+    def __ge__(self, other: Self) -> object:
         if self.__class__ is not other.__class__:
             return NotImplemented
 

chia/_tests/util/network_protocol_data.py

@@ -1,18 +1,32 @@
 from __future__ import annotations
 
 from chia_rs import (
+    ChallengeChainSubSlot,
+    CoinSpend,
+    CoinState,
+    EndOfSubSlotBundle,
     Foliage,
     FoliageBlockData,
     FoliageTransactionBlock,
+    FullBlock,
     G1Element,
     G2Element,
+    HeaderBlock,
+    InfusedChallengeChainSubSlot,
     PoolTarget,
+    ProofOfSpace,
+    RespondToPhUpdates,
     RewardChainBlock,
     RewardChainBlockUnfinished,
+    RewardChainSubSlot,
+    SpendBundle,
     SubEpochChallengeSegment,
     SubEpochData,
+    SubEpochSummary,
     SubSlotData,
+    SubSlotProofs,
     TransactionsInfo,
+    UnfinishedBlock,
 )
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import int16, uint8, uint16, uint32, uint64, uint128
@@ -29,23 +43,9 @@ from chia.protocols import (
 from chia.protocols.shared_protocol import Error
 from chia.types.blockchain_format.classgroup import ClassgroupElement
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.proof_of_space import ProofOfSpace
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.blockchain_format.slots import (
-    ChallengeChainSubSlot,
-    InfusedChallengeChainSubSlot,
-    RewardChainSubSlot,
-    SubSlotProofs,
-)
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
-from chia.types.coin_spend import CoinSpend
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
-from chia.types.full_block import FullBlock
-from chia.types.header_block import HeaderBlock
 from chia.types.peer_info import TimestampedPeerInfo
-from chia.types.spend_bundle import SpendBundle
-from chia.types.unfinished_block import UnfinishedBlock
 from chia.types.weight_proof import RecentChainData, WeightProof
 from chia.util.errors import Err
 
@@ -63,6 +63,7 @@ new_signage_point = farmer_protocol.NewSignagePoint(
     uint64(8265724497259558930),
     uint8(194),
     uint32(1),
+    uint32(0),
 )
 
 proof_of_space = ProofOfSpace(
@@ -641,7 +642,7 @@ respond_header_blocks = wallet_protocol.RespondHeaderBlocks(
     [header_block],
 )
 
-coin_state = wallet_protocol.CoinState(
+coin_state = CoinState(
     coin_1,
     uint32(2287030048),
     uint32(3361305811),
@@ -652,7 +653,7 @@ register_for_ph_updates = wallet_protocol.RegisterForPhUpdates(
     uint32(874269130),
 )
 
-respond_to_ph_updates = wallet_protocol.RespondToPhUpdates(
+respond_to_ph_updates = RespondToPhUpdates(
     [bytes32(bytes.fromhex("1be3bdc54b84901554e4e843966cfa3be3380054c968bebc41cc6be4aa65322f"))],
     uint32(3664709982),
     [coin_state],
@@ -794,7 +795,8 @@ new_signage_point_harvester = harvester_protocol.NewSignagePointHarvester(
     uint8(148),
     bytes32(bytes.fromhex("b78c9fca155e9742df835cbe84bb7e518bee70d78b6be6e39996c0a02e0cfe4c")),
     [pool_difficulty],
-    uint8(9),
+    uint32(0),
+    uint32(0),
 )
 
 new_proof_of_space = harvester_protocol.NewProofOfSpace(

chia/_tests/util/protocol_messages_json.py

@@ -12,6 +12,7 @@ new_signage_point_json: dict[str, Any] = {
     "sub_slot_iters": 8265724497259558930,
     "signage_point_index": 194,
     "peak_height": 1,
+    "last_tx_height": 0,
     "sp_source_data": None,
 }
 
@@ -2159,7 +2160,8 @@ new_signage_point_harvester_json: dict[str, Any] = {
             "pool_contract_puzzle_hash": "0xc9423123ea65e6923e973b95531b4874570dae942cb757a2daec4a6971753886",
         }
     ],
-    "filter_prefix_bits": 9,
+    "peak_height": 0,
+    "last_tx_height": 0,
 }
 
 new_proof_of_space_json: dict[str, Any] = {

chia/_tests/util/run_block.py

@@ -10,7 +10,7 @@ from chia_rs import Coin, ConsensusConstants
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
-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.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
@@ -60,7 +60,7 @@ def npc_to_dict(npc: NPC) -> dict[str, Any]:
 
 def run_generator(block_generator: BlockGenerator, constants: ConsensusConstants, max_cost: int) -> list[CAT]:
     block_args = block_generator.generator_refs
-    _cost, block_result = block_generator.program.run_with_cost(max_cost, [DESERIALIZE_MOD, block_args])
+    _cost, block_result = run_with_cost(block_generator.program, max_cost, [DESERIALIZE_MOD, block_args])
 
     coin_spends = block_result.first()
 

chia/_tests/util/setup_nodes.py

@@ -22,7 +22,7 @@ from chia.full_node.full_node_api import FullNodeAPI
 from chia.harvester.harvester import Harvester
 from chia.introducer.introducer_api import IntroducerAPI
 from chia.protocols.shared_protocol import Capability
-from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.server.aliases import FarmerService, FullNodeService, HarvesterService, TimelordService, WalletService
 from chia.server.server import ChiaServer
 from chia.simulator.block_tools import BlockTools, create_block_tools_async
 from chia.simulator.full_node_simulator import FullNodeSimulator
@@ -40,12 +40,12 @@ from chia.simulator.setup_services import (
 )
 from chia.simulator.socket import find_available_listen_port
 from chia.simulator.start_simulator import SimulatorFullNodeService
-from chia.types.aliases import FarmerService, FullNodeService, HarvesterService, TimelordService, WalletService
 from chia.types.peer_info import UnresolvedPeerInfo
 from chia.util.hash import std_hash
 from chia.util.keychain import Keychain
 from chia.util.timing import adjusted_timeout, backoff_times
 from chia.wallet.wallet_node import WalletNode
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 
 OldSimulatorsAndWallets = tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools]
 SimulatorsAndWalletsServices = tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools]
@@ -250,10 +250,10 @@ async def setup_simulators_and_wallets_inner(
     async with AsyncExitStack() as async_exit_stack:
         bt_tools: list[BlockTools] = [
             await create_block_tools_async(consensus_constants, keychain=keychain1, config_overrides=config_overrides)
-            for _ in range(0, simulator_count)
+            for _ in range(simulator_count)
         ]
         if wallet_count > simulator_count:
-            for _ in range(0, wallet_count - simulator_count):
+            for _ in range(wallet_count - simulator_count):
                 bt_tools.append(
                     await create_block_tools_async(
                         consensus_constants, keychain=keychain2, config_overrides=config_overrides
@@ -273,7 +273,7 @@ async def setup_simulators_and_wallets_inner(
                     disable_capabilities=disable_capabilities,
                 )
             )
-            for index in range(0, simulator_count)
+            for index in range(simulator_count)
         ]
 
         wallets: list[WalletService] = [
@@ -289,7 +289,7 @@ async def setup_simulators_and_wallets_inner(
                     initial_num_public_keys=initial_num_public_keys,
                 )
             )
-            for index in range(0, wallet_count)
+            for index in range(wallet_count)
         ]
 
         yield bt_tools, simulators, wallets
@@ -329,7 +329,7 @@ async def setup_farmer_multi_harvester(
                     start_service=start_services,
                 )
             )
-            for i in range(0, harvester_count)
+            for i in range(harvester_count)
         ]
 
         yield harvester_services, farmer_service, block_tools