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

chia/_tests/util/spend_sim.py

@@ -7,18 +7,21 @@ from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, Optional
 
 import anyio
 from chia_rs import (
     DONT_VALIDATE_SIGNATURE,
+    CoinSpend,
     ConsensusConstants,
     G2Element,
+    SpendBundle,
     get_flags_for_height_and_constants,
     run_block_generator2,
 )
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
+from typing_extensions import Self
 
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
@@ -32,16 +35,15 @@ from chia.full_node.mempool_manager import MempoolManager
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import INFINITE_COST
 from chia.types.coin_record import CoinRecord
-from chia.types.coin_spend import CoinSpend
 from chia.types.generator_types import BlockGenerator
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.mempool_item import MempoolItem
-from chia.types.spend_bundle import SpendBundle, T_SpendBundle
 from chia.util.db_wrapper import DBWrapper2
 from chia.util.errors import Err, ValidationError
 from chia.util.hash import std_hash
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.util.compute_hints import HintedCoin, compute_spend_hints_and_additions
+from chia.wallet.wallet_spend_bundle import T_SpendBundle
 
 """
 The purpose of this file is to provide a lightweight simulator for the testing of Chialisp smart contracts.
@@ -105,9 +107,6 @@ class SimFullBlock(Streamable):
     height: uint32  # Note that height is not on a regular FullBlock
 
 
-_T_SimBlockRecord = TypeVar("_T_SimBlockRecord", bound="SimBlockRecord")
-
-
 @streamable
 @dataclass(frozen=True)
 class SimBlockRecord(Streamable):
@@ -120,7 +119,7 @@ class SimBlockRecord(Streamable):
     prev_transaction_block_hash: bytes32
 
     @classmethod
-    def create(cls: type[_T_SimBlockRecord], rci: list[Coin], height: uint32, timestamp: uint64) -> _T_SimBlockRecord:
+    def create(cls, rci: list[Coin], height: uint32, timestamp: uint64) -> Self:
         prev_transaction_block_height = uint32(height - 1 if height > 0 else 0)
         return cls(
             rci,
@@ -142,9 +141,6 @@ class SimStore(Streamable):
     blocks: list[SimFullBlock]
 
 
-_T_SpendSim = TypeVar("_T_SpendSim", bound="SpendSim")
-
-
 class SpendSim:
     db_wrapper: DBWrapper2
     coin_store: CoinStore
@@ -159,8 +155,8 @@ class SpendSim:
     @classmethod
     @contextlib.asynccontextmanager
     async def managed(
-        cls: type[_T_SpendSim], db_path: Optional[Path] = None, defaults: ConsensusConstants = DEFAULT_CONSTANTS
-    ) -> AsyncIterator[_T_SpendSim]:
+        cls, db_path: Optional[Path] = None, defaults: ConsensusConstants = DEFAULT_CONSTANTS
+    ) -> AsyncIterator[Self]:
         self = cls()
         if db_path is None:
             uri = f"file:db_{random.randint(0, 99999999)}?mode=memory&cache=shared"
@@ -223,7 +219,7 @@ class SpendSim:
         coins = set()
         async with self.db_wrapper.reader_no_transaction() as conn:
             cursor = await conn.execute(
-                "SELECT puzzle_hash,coin_parent,amount from coin_record WHERE coinbase=0 AND spent_index==0 ",
+                "SELECT puzzle_hash,coin_parent,amount from coin_record WHERE coinbase=0 AND spent_index <= 0 ",
             )
             rows = await cursor.fetchall()
 
@@ -238,11 +234,7 @@ class SpendSim:
             return None
         return simple_solution_generator(bundle)
 
-    async def farm_block(
-        self,
-        puzzle_hash: bytes32 = bytes32(b"0" * 32),
-        item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
-    ) -> tuple[list[Coin], list[Coin]]:
+    async def farm_block(self, puzzle_hash: bytes32 = bytes32(b"0" * 32)) -> tuple[list[Coin], list[Coin]]:
         # Fees get calculated
         fees = uint64(0)
         for item in self.mempool_manager.mempool.all_items():
@@ -250,38 +242,34 @@ class SpendSim:
 
         # Rewards get created
         next_block_height: uint32 = uint32(self.block_height + 1) if len(self.block_records) > 0 else self.block_height
-        pool_coin: Coin = create_pool_coin(
-            next_block_height,
-            puzzle_hash,
-            calculate_pool_reward(next_block_height),
-            self.defaults.GENESIS_CHALLENGE,
-        )
-        farmer_coin: Coin = create_farmer_coin(
-            next_block_height,
-            puzzle_hash,
-            uint64(calculate_base_farmer_reward(next_block_height) + fees),
-            self.defaults.GENESIS_CHALLENGE,
-        )
-        await self.coin_store._add_coin_records(
-            [self.new_coin_record(pool_coin, True), self.new_coin_record(farmer_coin, True)]
-        )
-
+        included_reward_coins = [
+            create_pool_coin(
+                next_block_height,
+                puzzle_hash,
+                calculate_pool_reward(next_block_height),
+                self.defaults.GENESIS_CHALLENGE,
+            ),
+            create_farmer_coin(
+                next_block_height,
+                puzzle_hash,
+                uint64(calculate_base_farmer_reward(next_block_height) + fees),
+                self.defaults.GENESIS_CHALLENGE,
+            ),
+        ]
         # Coin store gets updated
         generator_bundle: Optional[SpendBundle] = None
-        return_additions: list[Coin] = []
-        return_removals: list[Coin] = []
+        tx_additions = []
+        tx_removals = []
         spent_coins_ids = None
         if (len(self.block_records) > 0) and (self.mempool_manager.mempool.size() > 0):
             peak = self.mempool_manager.peak
             if peak is not None:
-                result = await self.mempool_manager.create_bundle_from_mempool(
-                    last_tb_header_hash=peak.header_hash,
-                    item_inclusion_filter=item_inclusion_filter,
-                )
-
+                result = self.mempool_manager.create_bundle_from_mempool(last_tb_header_hash=peak.header_hash)
                 if result is not None:
                     bundle, additions = result
                     generator_bundle = bundle
+                    spent_coins: dict[bytes32, Coin] = {}
+                    spent_coins_ids = []
                     for spend in generator_bundle.coin_spends:
                         hint_dict, _ = compute_spend_hints_and_additions(spend)
                         hints: list[tuple[bytes32, bytes]] = []
@@ -290,21 +278,25 @@ class SpendSim:
                             if hint_obj.hint is not None:
                                 hints.append((coin_name, bytes(hint_obj.hint)))
                         await self.hint_store.add_hints(hints)
-                    return_additions = additions
-                    return_removals = bundle.removals()
-                    spent_coins_ids = [r.name() for r in return_removals]
-                    await self.coin_store._add_coin_records([self.new_coin_record(addition) for addition in additions])
-                    await self.coin_store._set_spent(spent_coins_ids, uint32(self.block_height + 1))
-
+                        spend_id = spend.coin.name()
+                        spent_coins[spend_id] = spend.coin
+                        spent_coins_ids.append(spend_id)
+                        tx_removals.append(spend.coin)
+                    for child in additions:
+                        parent = spent_coins.get(child.parent_coin_info)
+                        assert parent is not None
+                        same_as_parent = child.puzzle_hash == parent.puzzle_hash and child.amount == parent.amount
+                        tx_additions.append((child.name(), child, same_as_parent))
+        await self.coin_store.new_block(
+            height=uint32(self.block_height + 1),
+            timestamp=self.timestamp,
+            included_reward_coins=included_reward_coins,
+            tx_additions=tx_additions,
+            tx_removals=spent_coins_ids if spent_coins_ids is not None else [],
+        )
         # SimBlockRecord is created
         generator: Optional[BlockGenerator] = await self.generate_transaction_generator(generator_bundle)
-        self.block_records.append(
-            SimBlockRecord.create(
-                [pool_coin, farmer_coin],
-                next_block_height,
-                self.timestamp,
-            )
-        )
+        self.block_records.append(SimBlockRecord.create(included_reward_coins, next_block_height, self.timestamp))
         self.blocks.append(SimFullBlock(generator, next_block_height))
 
         # block_height is incremented
@@ -314,7 +306,7 @@ class SpendSim:
         await self.new_peak(spent_coins_ids)
 
         # return some debugging data
-        return return_additions, return_removals
+        return [a for _, a, _ in tx_additions], tx_removals
 
     def get_height(self) -> uint32:
         return self.block_height

chia/_tests/util/test_condition_tools.py

@@ -1,17 +1,16 @@
 from __future__ import annotations
 
 import pytest
-from chia_rs import G1Element
+from chia_rs import G1Element, SpendBundleConditions, SpendConditions
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
-from clvm.casts import int_to_bytes
 
+from chia.consensus.condition_tools import parse_sexp_to_conditions, pkm_pairs, pkm_pairs_for_conditions_dict
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
-from chia.types.spend_bundle_conditions import SpendBundleConditions, SpendConditions
-from chia.util.condition_tools import parse_sexp_to_conditions, pkm_pairs, pkm_pairs_for_conditions_dict
+from chia.util.casts import int_to_bytes
 from chia.util.errors import ConsensusError
 from chia.util.hash import std_hash
 
@@ -50,6 +49,8 @@ def mk_agg_sig_conditions(
         agg_sig_puzzle=agg_sig_data if opcode == ConditionOpcode.AGG_SIG_PUZZLE else [],
         agg_sig_puzzle_amount=agg_sig_data if opcode == ConditionOpcode.AGG_SIG_PUZZLE_AMOUNT else [],
         flags=0,
+        execution_cost=0,
+        condition_cost=0,
     )
     return SpendBundleConditions([spend], 0, 0, 0, None, None, agg_sig_unsafe_data, 0, 0, 0, False, 0, 0)
 

chia/_tests/util/test_config.py

@@ -6,9 +6,9 @@ from typing import Any, Optional
 from chia_rs.sized_ints import uint16
 
 from chia._tests.util.misc import DataCase, Marks, datacases
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
+from chia.server.resolve_peer_info import get_unresolved_peer_infos, set_peer_info
 from chia.types.peer_info import UnresolvedPeerInfo
-from chia.util.config import get_unresolved_peer_infos, set_peer_info
 
 
 @dataclass

chia/_tests/util/test_dump_keyring.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass
 from click.testing import CliRunner
 
 from chia._tests.util.misc import Marks, datacases
-from chia.util.dump_keyring import dump
+from chia.cmds.dump_keyring import dump
 from chia.util.keychain import Keychain
 
 output_prefix = """Attempting to dump contents of keyring file: {path}

chia/_tests/util/test_full_block_utils.py

@@ -6,38 +6,36 @@ from typing import Optional
 
 import pytest
 from chia_rs import (
+    ChallengeChainSubSlot,
+    EndOfSubSlotBundle,
     Foliage,
     FoliageBlockData,
     FoliageTransactionBlock,
+    FullBlock,
     G1Element,
     G2Element,
+    HeaderBlock,
+    InfusedChallengeChainSubSlot,
     PoolTarget,
+    ProofOfSpace,
     RewardChainBlock,
+    RewardChainSubSlot,
+    SubSlotProofs,
     TransactionsInfo,
 )
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
 from chia._tests.util.benchmarks import rand_bytes, rand_g1, rand_g2, rand_hash, rand_vdf, rand_vdf_proof, rewards
-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.vdf import VDFInfo, VDFProof
-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.util.full_block_utils import (
+from chia.consensus.generator_tools import get_block_header
+from chia.full_node.full_block_utils import (
     block_info_from_block,
     generator_from_block,
     get_height_and_tx_status_from_block,
     header_block_from_block,
 )
-from chia.util.generator_tools import get_block_header
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
 
 test_g2s: list[G2Element] = [rand_g2() for _ in range(10)]
 test_g1s: list[G1Element] = [rand_g1() for _ in range(10)]

chia/_tests/util/test_misc.py

@@ -13,8 +13,8 @@ from chia._tests.util.misc import RecordingWebServer
 from chia._tests.util.split_managers import SplitAsyncManager, SplitManager, split_async_manager, split_manager
 from chia._tests.wallet.test_singleton_lifecycle_fast import satisfies_hint
 from chia.cmds.cmds_util import format_bytes, format_minutes, validate_directory_writable
+from chia.full_node.tx_processing_queue import ValuedEvent
 from chia.types.blockchain_format.program import Program
-from chia.types.transaction_queue_entry import ValuedEvent
 from chia.util.batches import to_batches
 from chia.util.errors import InvalidPathError
 from chia.util.timing import adjusted_timeout, backoff_times
@@ -98,7 +98,7 @@ def test_empty_lists() -> None:
 @pytest.mark.parametrize("collection_type", [list, set])
 def test_valid(collection_type: type) -> None:
     for k in range(1, 10):
-        test_collection = collection_type([x for x in range(0, k)])
+        test_collection = collection_type([x for x in range(k)])
         for i in range(1, len(test_collection) + 1):  # Test batch_size 1 to 11 (length + 1)
             checked = 0
             for batch in to_batches(test_collection, i):

chia/_tests/util/test_paginator.py

@@ -35,8 +35,8 @@ def test_constructor_invalid_inputs(page_size: int, page_size_limit: int, except
 
 def test_page_count() -> None:
     for page_size in range(1, 10):
-        for i in range(0, 10):
-            assert Paginator.create(range(0, i), page_size).page_count() == max(1, ceil(i / page_size))
+        for i in range(10):
+            assert Paginator.create(range(i), page_size).page_count() == max(1, ceil(i / page_size))
 
 
 @pytest.mark.parametrize(
@@ -62,10 +62,10 @@ def test_page_count() -> None:
     ],
 )
 def test_get_page_valid(length: int, page: int, page_size: int, expected_data: list[int]) -> None:
-    assert Paginator.create(list(range(0, length)), page_size).get_page(page) == expected_data
+    assert Paginator.create(list(range(length)), page_size).get_page(page) == expected_data
 
 
 @pytest.mark.parametrize("page", [-1000, -10, -1, 5, 10, 1000])
 def test_get_page_invalid(page: int) -> None:
     with pytest.raises(PageOutOfBoundsError):
-        Paginator.create(range(0, 17), 5).get_page(page)
+        Paginator.create(range(17), 5).get_page(page)

chia/_tests/util/test_priority_mutex.py

@@ -128,7 +128,7 @@ class Request:
 
     def __lt__(self, other: Request) -> bool:
         if self.acquisition_order is None or other.acquisition_order is None:
-            raise RequestNotCompleteError()
+            raise RequestNotCompleteError
 
         return self.acquisition_order < other.acquisition_order
 
@@ -152,7 +152,7 @@ class Request:
 
     def before(self, other: Request) -> bool:
         if self.release_order is None or other.acquisition_order is None:
-            raise RequestNotCompleteError()
+            raise RequestNotCompleteError
 
         return self.release_order < other.acquisition_order
 

chia/_tests/util/test_replace_str_to_bytes.py

@@ -14,7 +14,7 @@ test_constants = ConsensusConstants(
     SLOT_BLOCKS_TARGET=uint32(32),
     MIN_BLOCKS_PER_CHALLENGE_BLOCK=uint8(16),
     MAX_SUB_SLOT_BLOCKS=uint32(128),
-    NUM_SPS_SUB_SLOT=uint32(64),
+    NUM_SPS_SUB_SLOT=uint8(64),
     SUB_SLOT_ITERS_STARTING=uint64(2**27),
     DIFFICULTY_CONSTANT_FACTOR=uint128(2**67),
     DIFFICULTY_STARTING=uint64(7),
@@ -23,9 +23,12 @@ test_constants = ConsensusConstants(
     EPOCH_BLOCKS=uint32(4608),
     SIGNIFICANT_BITS=uint8(8),
     DISCRIMINANT_SIZE_BITS=uint16(1024),
-    NUMBER_ZERO_BITS_PLOT_FILTER=uint8(9),
-    MIN_PLOT_SIZE=uint8(32),
-    MAX_PLOT_SIZE=uint8(50),
+    NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(9),
+    NUMBER_ZERO_BITS_PLOT_FILTER_V2=uint8(9),
+    MIN_PLOT_SIZE_V1=uint8(32),
+    MAX_PLOT_SIZE_V1=uint8(50),
+    MIN_PLOT_SIZE_V2=uint8(28),
+    MAX_PLOT_SIZE_V2=uint8(32),
     SUB_SLOT_TIME_TARGET=uint16(600),
     NUM_SP_INTERVALS_EXTRA=uint8(3),
     MAX_FUTURE_TIME2=uint32(2 * 60),
@@ -56,11 +59,18 @@ test_constants = ConsensusConstants(
     MAX_GENERATOR_SIZE=uint32(1000000),
     MAX_GENERATOR_REF_LIST_SIZE=uint32(512),
     POOL_SUB_SLOT_ITERS=uint64(37600000000),
-    SOFT_FORK6_HEIGHT=uint32(6800000),
     HARD_FORK_HEIGHT=uint32(5496000),
+    HARD_FORK2_HEIGHT=uint32(0xFFFFFFFF),
+    PLOT_V1_PHASE_OUT=uint32(1179648),
     PLOT_FILTER_128_HEIGHT=uint32(10542000),
     PLOT_FILTER_64_HEIGHT=uint32(15592000),
     PLOT_FILTER_32_HEIGHT=uint32(20643000),
+    PLOT_DIFFICULTY_INITIAL=uint8(2),
+    PLOT_DIFFICULTY_4_HEIGHT=uint32(0xFFFFFFFF),
+    PLOT_DIFFICULTY_5_HEIGHT=uint32(0xFFFFFFFF),
+    PLOT_DIFFICULTY_6_HEIGHT=uint32(0xFFFFFFFF),
+    PLOT_DIFFICULTY_7_HEIGHT=uint32(0xFFFFFFFF),
+    PLOT_DIFFICULTY_8_HEIGHT=uint32(0xFFFFFFFF),
 )
 
 

chia/_tests/util/test_ssl_check.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import pytest
 
 from chia.ssl.create_ssl import create_all_ssl
-from chia.util.ssl_check import check_ssl
+from chia.ssl.ssl_check import check_ssl
 
 
 def test_check_ssl_stream_with_bad_permissions(

chia/_tests/util/test_testnet_overrides.py

@@ -8,9 +8,19 @@ from chia.consensus.default_constants import update_testnet_overrides
 def test_testnet11() -> None:
     overrides: dict[str, Any] = {}
     update_testnet_overrides("testnet11", overrides)
-    assert overrides == {
-        "SOFT_FORK6_HEIGHT": 2000000,
-    }
+    assert overrides == {"MIN_PLOT_SIZE_V2": 18}
+
+
+def test_min_plot_size() -> None:
+    overrides: dict[str, Any] = {"MIN_PLOT_SIZE": 18}
+    update_testnet_overrides("testnet11", overrides)
+    assert overrides == {"MIN_PLOT_SIZE_V1": 18, "MIN_PLOT_SIZE_V2": 18}
+
+
+def test_max_plot_size() -> None:
+    overrides: dict[str, Any] = {"MAX_PLOT_SIZE": 32}
+    update_testnet_overrides("testnet11", overrides)
+    assert overrides == {"MAX_PLOT_SIZE_V1": 32, "MIN_PLOT_SIZE_V2": 18}
 
 
 def test_mainnet() -> None:

chia/_tests/util/time_out_assert.py

@@ -11,11 +11,13 @@ from inspect import getframeinfo, stack
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Protocol, TypeVar, cast, final
 
+from typing_extensions import Self
+
 import chia
 import chia._tests
 from chia._tests import ether
+from chia.protocols.outbound_message import Message
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.server.outbound_message import Message
 from chia.util.timing import adjusted_timeout
 
 log = logging.getLogger(__name__)
@@ -37,7 +39,7 @@ class DataTypeProtocol(Protocol):
     __match_args__: ClassVar[tuple[str, ...]] = ()
 
     @classmethod
-    def unmarshal(cls: type[T], marshalled: dict[str, Any]) -> T: ...
+    def unmarshal(cls, marshalled: dict[str, Any]) -> Self: ...
 
     def marshal(self) -> dict[str, Any]: ...
 

chia/_tests/wallet/cat_wallet/test_cat_lifecycle.py

@@ -5,7 +5,6 @@ from typing import Optional
 import pytest
 from chia_rs import AugSchemeMPL, G2Element, PrivateKey
 from chia_rs.sized_ints import uint64
-from clvm.casts import int_to_bytes
 
 from chia._tests.clvm.benchmark_costs import cost_of_spend_bundle
 from chia._tests.clvm.test_puzzles import secret_exponent_for_index
@@ -15,6 +14,7 @@ from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.coin_spend import make_spend
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.util.casts import int_to_bytes
 from chia.util.errors import Err
 from chia.wallet.cat_wallet.cat_utils import (
     CAT_MOD,

chia/_tests/wallet/cat_wallet/test_cat_outer_puzzle.py

@@ -9,7 +9,6 @@ from clvm_tools.binutils import disassemble
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.coin_spend import make_spend
 from chia.wallet.cat_wallet.cat_utils import CAT_MOD, construct_cat_puzzle
 from chia.wallet.outer_puzzles import construct_puzzle, get_inner_puzzle, get_inner_solution, match_puzzle, solve_puzzle
@@ -38,7 +37,7 @@ def test_cat_outer_puzzle() -> None:
     # Set up for solve
     parent_coin = Coin(tail, double_cat_puzzle.get_tree_hash(), uint64(100))
     child_coin = Coin(parent_coin.name(), double_cat_puzzle.get_tree_hash(), uint64(100))
-    parent_spend = make_spend(parent_coin, SerializedProgram.from_program(double_cat_puzzle), Program.to([]))
+    parent_spend = make_spend(parent_coin, double_cat_puzzle, Program.to([]))
     child_coin_as_hex: str = (
         "0x"
         + child_coin.parent_coin_info.hex()