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

chia/_tests/cmds/wallet/test_wallet.py

@@ -9,7 +9,7 @@ import importlib_resources
 import pytest
 from chia_rs import Coin, G2Element
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint8, uint32, uint64
+from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 from click.testing import CliRunner
 
 from chia._tests.cmds.cmd_test_utils import TestRpcClients, TestWalletRpcClient, logType, run_cli_command_and_assert
@@ -25,15 +25,7 @@ from chia._tests.cmds.wallet.test_consts import (
     get_bytes32,
 )
 from chia.cmds.cmds_util import TransactionBundle
-from chia.rpc.wallet_request_types import (
-    CancelOfferResponse,
-    CATSpendResponse,
-    CreateOfferForIDsResponse,
-    GetHeightInfoResponse,
-    SendTransactionResponse,
-    TakeOfferResponse,
-)
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
 from chia.types.blockchain_format.program import Program
 from chia.types.signing_mode import SigningMode
 from chia.util.bech32m import encode_puzzle_hash
@@ -48,6 +40,19 @@ from chia.wallet.util.transaction_type import TransactionType
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet_coin_store import GetCoinRecords
+from chia.wallet.wallet_request_types import (
+    CancelOfferResponse,
+    CATSpendResponse,
+    CreateOfferForIDsResponse,
+    FungibleAsset,
+    GetHeightInfoResponse,
+    NFTCalculateRoyalties,
+    NFTGetWalletDID,
+    NFTGetWalletDIDResponse,
+    RoyaltyAsset,
+    SendTransactionResponse,
+    TakeOfferResponse,
+)
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 test_offer_file_path = importlib_resources.files(__name__.rpartition(".")[0]).joinpath("test_offer.toffer")
@@ -246,9 +251,9 @@ def test_show(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path])
                 "unconfirmed_wallet_balance": uint64(0),
             }
 
-        async def get_nft_wallet_did(self, wallet_id: uint8) -> dict[str, Optional[str]]:
-            self.add_to_log("get_nft_wallet_did", (wallet_id,))
-            return {"did_id": "0xcee228b8638c67cb66a55085be99fa3b457ae5b56915896f581990f600b2c652"}
+        async def get_nft_wallet_did(self, request: NFTGetWalletDID) -> NFTGetWalletDIDResponse:
+            self.add_to_log("get_nft_wallet_did", (request.wallet_id,))
+            return NFTGetWalletDIDResponse("did:chia:1qgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpq4msw0c")
 
         async def get_connections(
             self, node_type: Optional[NodeType] = None
@@ -277,7 +282,7 @@ def test_show(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path])
         "test2:\n   -Total Balance:         2000000.0  (2000000000 mojo)",
         "   -Asset ID:              dc59bcd60ce5fc9c93a5d3b11875486b03efb53a53da61e453f5cf61a7746860",
         "NFT Wallet:\n   -Total Balance:         1.0",
-        "   -DID ID:                0xcee228b8638c67cb66a55085be99fa3b457ae5b56915896f581990f600b2c652",
+        "   -DID ID:                did:chia:1qgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpq4msw0c",
         "FULL_NODE 127.0.0.1",
         "47482/47482 01010101... May 12",
     ]
@@ -661,12 +666,14 @@ def test_add_token(capsys: object, get_test_cli_clients: tuple[TestRpcClients, P
     assert_list = [f"Successfully renamed test1 with wallet_id 2 on key {FINGERPRINT} to examplecat"]
     other_assert_list = [f"Successfully added examplecat with wallet id 3 on key {FINGERPRINT}"]
     run_cli_command_and_assert(capsys, root_dir, [*command_args, "--asset-id", get_bytes32(1).hex()], assert_list)
-    run_cli_command_and_assert(capsys, root_dir, [*command_args, "--asset-id", get_bytes32(3).hex()], other_assert_list)
+    run_cli_command_and_assert(
+        capsys, root_dir, [*command_args, "--asset-id", bytes32([1, 2] * 16).hex()], other_assert_list
+    )
     # these are various things that should be in the output
 
     expected_calls: logType = {
-        "cat_asset_id_to_name": [(get_bytes32(1),), (get_bytes32(3),)],
-        "create_wallet_for_existing_cat": [(get_bytes32(3),)],
+        "cat_asset_id_to_name": [(get_bytes32(1),), (bytes32([1, 2] * 16),)],
+        "create_wallet_for_existing_cat": [(bytes32([1, 2] * 16),)],
         "set_cat_name": [(2, "examplecat"), (3, "examplecat")],
     }
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
@@ -765,6 +772,7 @@ def test_make_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
 
     inst_rpc_client = MakeOfferRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
+    offer_cat_id = get_bytes32(4)
     request_cat_id = get_bytes32(2)
     request_nft_id = get_bytes32(2)
     request_nft_addr = encode_puzzle_hash(request_nft_id, "nft")
@@ -780,6 +788,8 @@ def test_make_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
         "1:10",
         "--offer",
         "3:100",
+        "--offer",
+        f"{offer_cat_id.hex()}:100",
         "--request",
         f"{request_cat_id.hex()}:10",
         "--request",
@@ -790,7 +800,7 @@ def test_make_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
         "150",
     ]
     assert_list = [
-        "OFFERING:\n  - 10 XCH (10000000000000 mojos)\n  - 100 test3 (100000 mojos)",
+        "OFFERING:\n  - 10 XCH (10000000000000 mojos)\n  - 100 test3 (100000 mojos)\n  - 100 test4 (100000 mojos)",
         "REQUESTING:\n  - 10 test2 (10000 mojos)\n"
         "  - 1 nft1qgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyql4ft (1 mojos)",
         "Including Fees: 0.5 XCH, 500000000000 mojos",
@@ -799,18 +809,34 @@ def test_make_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
     run_cli_command_and_assert(capsys, root_dir, command_args[:-8], ["without --override"])
     run_cli_command_and_assert(capsys, root_dir, command_args, assert_list)
     expected_calls: logType = {
-        "cat_asset_id_to_name": [(request_cat_id,)],
+        "cat_asset_id_to_name": [(offer_cat_id,), (request_cat_id,)],
         "get_nft_info": [(request_nft_id.hex(), True)],
         "get_cat_name": [(3,)],
         "nft_calculate_royalties": [
             (
-                {
-                    "nft1qgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyql4ft": (
-                        "xch1qvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvps82kgr2",
-                        1000,
-                    )
-                },
-                {"XCH": 10000000000000, "test3": 100000},
+                NFTCalculateRoyalties(
+                    [
+                        RoyaltyAsset(
+                            "nft1qgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyql4ft",
+                            "xch1qvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvps82kgr2",
+                            uint16(1000),
+                        )
+                    ],
+                    [
+                        FungibleAsset(
+                            "XCH",
+                            uint64(10000000000000),
+                        ),
+                        FungibleAsset(
+                            "test3",
+                            uint64(100000),
+                        ),
+                        FungibleAsset(
+                            "test4",
+                            uint64(100000),
+                        ),
+                    ],
+                ),
             )
         ],
         "create_offer_for_ids": [
@@ -818,6 +844,7 @@ def test_make_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
                 {
                     1: -10000000000000,
                     3: -100000,
+                    "0404040404040404040404040404040404040404040404040404040404040404": -100000,
                     "0202020202020202020202020202020202020202020202020202020202020202": 10000,
                     "0101010101010101010101010101010101010101010101010101010101010101": 1,
                 },
@@ -998,17 +1025,39 @@ def test_take_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
                 ),
             )
 
+        async def cat_asset_id_to_name(self, asset_id: bytes32) -> Optional[tuple[Optional[uint32], str]]:
+            self.add_to_log("cat_asset_id_to_name", (asset_id,))
+            if asset_id == cat_offered_id:
+                return uint32(2), "offered cat"
+            elif asset_id == cat_requested_id:
+                return uint32(3), "requested cat"
+            else:
+                return None
+
     inst_rpc_client = TakeOfferRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     # these are various things that should be in the output
-    cat1 = bytes32.from_hexstr("fd6a341ed39c05c31157d5bfea395a0e142398ced24deea1e82f836d7ec2909c")
-    cat2 = bytes32.from_hexstr("dc59bcd60ce5fc9c93a5d3b11875486b03efb53a53da61e453f5cf61a7746860")
+    nft_offered_id = bytes32.from_hexstr("6bc2c2a27c0f04b9e1e57933d2efe08f5b9e156652a374436b70c067b03c444c")
+    cat_offered_id = bytes32.from_hexstr("06e4136cb7295cec5265c5e49cc32fa69aede779532f2b7542a2456589a53f2f")
+    cat_requested_id = bytes32.from_hexstr("13a52e5efb1ee80a24c94b36bbda2b473094353614ced1c2938ba5ef6097431e")
+    nft_requested_id_1 = bytes32.from_hexstr("7657b5f1cdee70459052c314f839bb1b76b8c3f444671da71ad7dfcb6c47f243")
+    nft_requested_id_2 = bytes32.from_hexstr("5f03cdb94c96325f49f4abf1d4d10cabd5ea583632fbf20f251b7fad73645a14")
     assert_list = [
-        f"  OFFERED:\n    - XCH (Wallet ID: 1): 10.0 (10000000000000 mojos)\n    - {cat1.hex()}: 100.0 (100000 mojos)",
+        "  OFFERED:\n"
+        f"    - {nft_offered_id.hex()}: 0.001 (1 mojo)\n"
+        f"    - offered cat (Wallet ID: 2): 100.0 (100000 mojos)\n",
         "  REQUESTED:\n"
-        f"    - {cat2.hex()}: 10.0 (10000 mojos)\n"
-        "    - accce8e1c71b56624f2ecaeff5af57eac41365080449904d0717bd333c04806d: 0.001 (1 mojo)",
-        "Accepted offer with ID dfb7e8643376820ec995b0bcdb3fc1f764c16b814df5e074631263fcf1e00839",
+        "    - XCH (Wallet ID: 1): 2.0 (2000000000000 mojos)\n"
+        f"    - {nft_requested_id_1.hex()}: 0.001 (1 mojo)\n"
+        f"    - {nft_requested_id_2.hex()}: 0.001 (1 mojo)\n",
+        "    - requested cat (Wallet ID: 3): 100.0 (100000 mojos)\n",
+        "Royalties Summary:\n"
+        f"  - For {encode_puzzle_hash(nft_offered_id, 'nft')}:\n"
+        "    - 0.2 XCH (200000000000 mojos) to xch1qvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvps82kgr2\n"
+        "    - 10 requested cat (10000 mojos) to xch1qvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvps82kgr2\n",
+        "Total Amounts Requested:\n",
+        "  - 2.2 XCH (2200000000000 mojos)\n  - 110 requested cat (110000 mojos)\n",
+        "Accepted offer with ID 71fd6de245d896c691b0115cdb9b47904cb60858ae87b86bfd648b23208b6cc1",
     ]
 
     with importlib_resources.as_file(test_offer_file_path) as test_offer_file_name:
@@ -1028,9 +1077,12 @@ def test_take_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
 
     expected_calls: logType = {
         "cat_asset_id_to_name": [
-            (cat1,),
-            (cat2,),
-            (bytes32.from_hexstr("accce8e1c71b56624f2ecaeff5af57eac41365080449904d0717bd333c04806d"),),
+            (nft_offered_id,),
+            (cat_offered_id,),
+            (nft_requested_id_1,),
+            (nft_requested_id_2,),
+            (cat_requested_id,),
+            (cat_requested_id,),
         ],
         "take_offer": [
             (
@@ -1096,14 +1148,13 @@ def test_cancel_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients
         "150",
     ]
     # these are various things that should be in the output
-    cat1 = bytes32.from_hexstr("fd6a341ed39c05c31157d5bfea395a0e142398ced24deea1e82f836d7ec2909c")
-    cat2 = bytes32.from_hexstr("dc59bcd60ce5fc9c93a5d3b11875486b03efb53a53da61e453f5cf61a7746860")
+    nft_offered_id = bytes32.from_hexstr("6bc2c2a27c0f04b9e1e57933d2efe08f5b9e156652a374436b70c067b03c444c")
+    cat_offered_id = bytes32.from_hexstr("06e4136cb7295cec5265c5e49cc32fa69aede779532f2b7542a2456589a53f2f")
+    cat_requested_id = bytes32.from_hexstr("13a52e5efb1ee80a24c94b36bbda2b473094353614ced1c2938ba5ef6097431e")
+    nft_requested_id_1 = bytes32.from_hexstr("7657b5f1cdee70459052c314f839bb1b76b8c3f444671da71ad7dfcb6c47f243")
+    nft_requested_id_2 = bytes32.from_hexstr("5f03cdb94c96325f49f4abf1d4d10cabd5ea583632fbf20f251b7fad73645a14")
     assert_list = [
-        f"  OFFERED:\n    - XCH (Wallet ID: 1): 10.0 (10000000000000 mojos)\n    - {cat1.hex()}: 100.0 (100000 mojos)",
-        "  REQUESTED:\n"
-        f"    - {cat2.hex()}: 10.0 (10000 mojos)\n"
-        "    - accce8e1c71b56624f2ecaeff5af57eac41365080449904d0717bd333c04806d: 0.001 (1 mojo)",
-        "Cancelled offer with ID dfb7e8643376820ec995b0bcdb3fc1f764c16b814df5e074631263fcf1e00839",
+        "Cancelled offer with ID 71fd6de245d896c691b0115cdb9b47904cb60858ae87b86bfd648b23208b6cc1",
     ]
     run_cli_command_and_assert(capsys, root_dir, command_args, assert_list)
     expected_calls: logType = {
@@ -1112,10 +1163,13 @@ def test_cancel_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients
             (test_offer_id_bytes, DEFAULT_TX_CONFIG, 500000000000, True, True, test_condition_valid_times)
         ],
         "cat_asset_id_to_name": [
-            (cat1,),
-            (cat2,),
-            (bytes32.from_hexstr("accce8e1c71b56624f2ecaeff5af57eac41365080449904d0717bd333c04806d"),),
-            (cat1,),
+            (nft_offered_id,),
+            (cat_offered_id,),
+            (nft_requested_id_1,),
+            (nft_requested_id_2,),
+            (cat_requested_id,),
+            (nft_offered_id,),
+            (cat_offered_id,),
         ],
     }
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)

chia/_tests/conftest.py

@@ -49,11 +49,18 @@ from chia._tests.util.setup_nodes import (
 )
 from chia._tests.util.spend_sim import CostLogger
 from chia._tests.util.time_out_assert import time_out_assert
+from chia.farmer.farmer_rpc_client import FarmerRpcClient
 from chia.full_node.full_node_api import FullNodeAPI
-from chia.rpc.farmer_rpc_client import FarmerRpcClient
-from chia.rpc.harvester_rpc_client import HarvesterRpcClient
-from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.harvester.harvester_rpc_client import HarvesterRpcClient
 from chia.seeder.dns_server import DNSServer
+from chia.server.aliases import (
+    CrawlerService,
+    FarmerService,
+    FullNodeService,
+    HarvesterService,
+    TimelordService,
+    WalletService,
+)
 from chia.server.server import ChiaServer
 from chia.server.start_service import Service
 from chia.simulator.full_node_simulator import FullNodeSimulator
@@ -67,16 +74,6 @@ from chia.simulator.setup_services import (
 )
 from chia.simulator.start_simulator import SimulatorFullNodeService
 from chia.simulator.wallet_tools import WalletTool
-
-# Set spawn after stdlib imports, but before other imports
-from chia.types.aliases import (
-    CrawlerService,
-    FarmerService,
-    FullNodeService,
-    HarvesterService,
-    TimelordService,
-    WalletService,
-)
 from chia.types.peer_info import PeerInfo
 from chia.util.config import create_default_chia_config, lock_and_load_config
 from chia.util.db_wrapper import generate_in_memory_db_uri
@@ -84,7 +81,10 @@ from chia.util.keychain import Keychain
 from chia.util.task_timing import main as task_instrumentation_main
 from chia.util.task_timing import start_task_instrumentation, stop_task_instrumentation
 from chia.wallet.wallet_node import WalletNode
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 
+# TODO: review how this is now after other imports and before some stdlib imports...  :[
+# Set spawn after stdlib imports, but before other imports
 multiprocessing.set_start_method("spawn")
 
 from dataclasses import replace
@@ -94,7 +94,7 @@ from chia_rs.sized_ints import uint128
 
 from chia._tests.environments.wallet import WalletEnvironment, WalletState, WalletTestFramework
 from chia._tests.util.setup_nodes import setup_farmer_multi_harvester
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 from chia.simulator.block_tools import BlockTools, create_block_tools_async, test_constants
 from chia.simulator.keyring import TempKeyring
 from chia.util.keyring_wrapper import KeyringWrapper
@@ -196,12 +196,12 @@ def get_keychain():
 class ConsensusMode(ComparableEnum):
     PLAIN = 0
     HARD_FORK_2_0 = 1
-    SOFT_FORK_6 = 2
+    HARD_FORK_3_0 = 2
 
 
 @pytest.fixture(
     scope="session",
-    params=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0, ConsensusMode.SOFT_FORK_6],
+    params=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0, ConsensusMode.HARD_FORK_3_0],
 )
 def consensus_mode(request):
     return request.param
@@ -217,10 +217,16 @@ def blockchain_constants(consensus_mode: ConsensusMode) -> ConsensusConstants:
             PLOT_FILTER_64_HEIGHT=uint32(15),
             PLOT_FILTER_32_HEIGHT=uint32(20),
         )
-    if consensus_mode >= ConsensusMode.SOFT_FORK_6:
+
+    if consensus_mode >= ConsensusMode.HARD_FORK_3_0:
         ret = ret.replace(
-            SOFT_FORK6_HEIGHT=uint32(2),
+            HARD_FORK_HEIGHT=uint32(2),
+            PLOT_FILTER_128_HEIGHT=uint32(10),
+            PLOT_FILTER_64_HEIGHT=uint32(15),
+            PLOT_FILTER_32_HEIGHT=uint32(20),
+            HARD_FORK2_HEIGHT=uint32(2),
         )
+
     return ret
 
 
@@ -468,6 +474,11 @@ def default_10000_blocks_compact(bt, consensus_mode):
     )
 
 
+# If you add another test chain, don't forget to also add a "build_test_chains"
+# generator to chia/_tests/blockchain/test_build_chains.py as well as a test in
+# the same file.
+
+
 @pytest.fixture(scope="function")
 def tmp_dir():
     with tempfile.TemporaryDirectory() as folder:
@@ -1236,8 +1247,8 @@ async def farmer_harvester_2_simulators_zero_bits_plot_filter(
     ]
 ]:
     zero_bit_plot_filter_consts = test_constants_modified.replace(
-        NUMBER_ZERO_BITS_PLOT_FILTER=uint8(0),
-        NUM_SPS_SUB_SLOT=uint32(8),
+        NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(0),
+        NUM_SPS_SUB_SLOT=uint8(8),
     )
 
     async with AsyncExitStack() as async_exit_stack:

chia/_tests/connection_utils.py

@@ -13,8 +13,8 @@ from cryptography.hazmat.primitives import hashes, serialization
 
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.apis import ApiProtocolRegistry
+from chia.protocols.outbound_message import NodeType
 from chia.protocols.shared_protocol import default_capabilities
-from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer, ssl_context_for_client
 from chia.server.ssl_context import chia_ssl_ca_paths, private_ssl_ca_paths
 from chia.server.ws_connection import WSChiaConnection

chia/_tests/core/consensus/stores/test_coin_store_protocol.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import pytest
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
+
+from chia._tests.util.db_connection import DBConnection
+from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
+from chia.full_node.coin_store import CoinStore
+
+# black box tests from `chia/_tests/core/full_node/stores/test_coin_store.py`
+# should be moved here
+
+
+@pytest.mark.anyio
+async def test_is_empty_when_empty(db_version: int) -> None:
+    async with DBConnection(db_version) as db_wrapper:
+        coin_store = await CoinStore.create(db_wrapper)
+        assert await coin_store.is_empty() is True
+
+
+@pytest.mark.anyio
+async def test_is_empty_when_not_empty(db_version: int) -> None:
+    async with DBConnection(db_version) as db_wrapper:
+        coin_store = await CoinStore.create(db_wrapper)
+        assert await coin_store.is_empty() is True
+        height = uint32(1)
+        genesis_challenge = bytes32(b"\0" * 32)
+        pool_puzzle_hash = bytes32(b"\x01" * 32)
+        farmer_puzzle_hash = bytes32(b"\x02" * 32)
+        pool_coin = create_pool_coin(height, pool_puzzle_hash, uint64(1_750_000_000_000), genesis_challenge)
+        farmer_coin = create_farmer_coin(height, farmer_puzzle_hash, uint64(1_750_000_000_000), genesis_challenge)
+        await coin_store.new_block(
+            height=height,
+            timestamp=uint64(1234567890),
+            included_reward_coins=[pool_coin, farmer_coin],
+            tx_additions=[],
+            tx_removals=[],
+        )
+        assert await coin_store.is_empty() is False

chia/_tests/core/consensus/test_block_creation.py

@@ -2,12 +2,9 @@ from __future__ import annotations
 
 import pytest
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint32, uint64
+from chia_rs.sized_ints import uint64
 
-from chia._tests.core.make_block_generator import make_block_generator
-from chia.consensus.block_creation import compute_block_cost, compute_block_fee
-from chia.consensus.condition_costs import ConditionCost
-from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.consensus.block_creation import compute_block_fee
 from chia.types.blockchain_format.coin import Coin
 
 
@@ -26,29 +23,3 @@ def test_compute_block_fee(add_amount: list[int], rem_amount: list[int]) -> None
             compute_block_fee(additions, removals)
     else:
         assert compute_block_fee(additions, removals) == expected
-
-
-def test_compute_block_cost(softfork_height: uint32) -> None:
-    num_coins = 10
-    generator = make_block_generator(num_coins)
-    cost = int(compute_block_cost(generator, DEFAULT_CONSTANTS, softfork_height))
-
-    coin_cost = ConditionCost.CREATE_COIN.value * num_coins
-    agg_sig_cost = ConditionCost.AGG_SIG.value * num_coins
-
-    cost -= coin_cost
-    cost -= agg_sig_cost
-    cost -= len(bytes(generator.program)) * DEFAULT_CONSTANTS.COST_PER_BYTE
-
-    print(f"{cost=}")
-
-    # the cost is a non-trivial combination of the CLVM cost of running the puzzles
-    # and before the hard-fork, combined with the cost of running the generator ROM
-    # Consensus requires these costs to be unchanged over time, so this test
-    # ensures compatibility
-    if softfork_height >= DEFAULT_CONSTANTS.HARD_FORK_HEIGHT:
-        expected = 180980
-    else:
-        expected = 3936699
-
-    assert cost == expected

chia/_tests/core/consensus/test_pot_iterations.py

@@ -1,19 +1,25 @@
 from __future__ import annotations
 
+from chia_rs import PlotSize
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64, uint128
 from pytest import raises
 
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.pos_quality import _expected_plot_size
 from chia.consensus.pot_iterations import (
+    PHASE_OUT_PERIOD,
     calculate_ip_iters,
     calculate_iterations_quality,
+    calculate_phase_out,
+    calculate_sp_interval_iters,
     calculate_sp_iters,
     is_overflow_block,
 )
 from chia.util.hash import std_hash
 
-test_constants = DEFAULT_CONSTANTS.replace(NUM_SPS_SUB_SLOT=uint32(32), SUB_SLOT_TIME_TARGET=uint16(300))
+test_constants = DEFAULT_CONSTANTS.replace(
+    NUM_SPS_SUB_SLOT=uint8(32), SUB_SLOT_TIME_TARGET=uint16(300), HARD_FORK2_HEIGHT=uint32(100000000)
+)
 
 
 class TestPotIterations:
@@ -98,7 +104,7 @@ class TestPotIterations:
         num_sps = 16
         sp_interval_iters = uint64(100000000 // 32)
         difficulty = uint64(500000000000)
-
+        constants = test_constants.replace(DIFFICULTY_CONSTANT_FACTOR=uint128(2**25))
         for slot_index in range(total_slots):
             total_wins_in_slot = 0
             for sp_index in range(num_sps):
@@ -106,7 +112,10 @@ class TestPotIterations:
                 for k, count in farmer_ks.items():
                     for farmer_index in range(count):
                         quality = std_hash(slot_index.to_bytes(4, "big") + k.to_bytes(1, "big") + bytes(farmer_index))
-                        required_iters = calculate_iterations_quality(uint128(2**25), quality, k, difficulty, sp_hash)
+                        # TODO: todo_v2_plots
+                        required_iters = calculate_iterations_quality(
+                            constants, quality, PlotSize.make_v1(k), difficulty, sp_hash, uint64(100000000), uint32(0)
+                        )
                         if required_iters < sp_interval_iters:
                             wins[k] += 1
                             total_wins_in_slot += 1
@@ -115,3 +124,29 @@ class TestPotIterations:
         for k in farmer_ks.keys():
             # Win rate is proportional to percentage of space
             assert abs(win_percentage[k] - percentage_space[k]) < 0.01
+
+    def test_calculate_phase_out(self):
+        constants = test_constants
+        sub_slot_iters = uint64(100000000000)
+        sp_interval = calculate_sp_interval_iters(constants, sub_slot_iters)
+        # Before or at HARD_FORK2_HEIGHT, should return 0
+        assert calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT - 1) == 0
+        assert calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT) == 0
+        # after HARD_FORK2_HEIGHT, should return value = delta/phase_out_period * sp_interval
+        assert (
+            calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT + 1)
+            == sp_interval // PHASE_OUT_PERIOD
+        )
+        assert (
+            calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT + PHASE_OUT_PERIOD // 2)
+            == sp_interval // 2
+        )
+        assert (
+            calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT + PHASE_OUT_PERIOD)
+            == sp_interval
+        )
+
+        # Test with maximum uint32 height to ensure no overflow
+        max_uint32_height = uint32(0xFFFFFFFF)
+        result_max_height = calculate_phase_out(constants, sub_slot_iters, max_uint32_height)
+        assert result_max_height == sp_interval  # Should cap at sp_interval