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

chia/_tests/blockchain/test_build_chains.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
 
+from typing import Optional
+
 import pytest
+from chia_rs import Coin, ConsensusConstants, FullBlock, additions_and_removals, get_flags_for_height_and_constants
+from chia_rs.sized_ints import uint64
 
-from chia.types.full_block import FullBlock
+from chia.simulator.block_tools import BlockTools
 
 # These test targets are used to trigger a build of the test chains.
 # On CI we clone the test-cache repository to load the chains from, so they
@@ -57,3 +61,195 @@ def test_trigger_default_2000_compact(default_2000_blocks_compact: list[FullBloc
 @pytest.mark.build_test_chains
 def test_trigger_default_10000_compact(default_10000_blocks_compact: list[FullBlock]) -> None:
     pass
+
+
+def validate_coins(constants: ConsensusConstants, blocks: list[FullBlock]) -> None:
+    unspent_coins: set[Coin] = set()
+    for block in blocks:
+        rewards = block.get_included_reward_coins()
+
+        if block.transactions_generator is not None:
+            flags = get_flags_for_height_and_constants(block.height, constants)
+            additions, removals = additions_and_removals(
+                bytes(block.transactions_generator),
+                [],
+                flags,
+                constants,
+            )
+
+            for _, rem in removals:
+                try:
+                    unspent_coins.remove(rem)
+                except KeyError:  # pragma: no cover
+                    print(f"at height: {block.height} removal: {rem} does not exist")
+                    print("coinset: ", unspent_coins)
+                    raise
+
+            for add, _ in additions:
+                unspent_coins.add(add)
+
+        for add in rewards:
+            unspent_coins.add(add)
+
+
+def validate_chain(
+    bt: BlockTools,
+    blocks: list[FullBlock],
+    *,
+    seed: bytes = b"",
+    empty_sub_slots: int = 0,
+    normalized_to_identity_cc_eos: bool = False,
+    normalized_to_identity_icc_eos: bool = False,
+    normalized_to_identity_cc_sp: bool = False,
+    normalized_to_identity_cc_ip: bool = False,
+    block_list_input: Optional[list[FullBlock]] = None,
+    time_per_block: Optional[float] = None,
+    dummy_block_references: bool = False,
+    include_transactions: bool = False,
+) -> None:
+    validate_coins(bt.constants, blocks)
+
+    # make sure that the blocks we found on-disk are consistent with
+    # the ones we would have generated
+    input_length = len(block_list_input) if block_list_input else 0
+
+    # 80 blocks is a balance between capturing all features of the
+    # chains (such as block references) versus the cost of
+    # generating and comparing blocks.
+    request_length = min(80, len(blocks) - input_length)
+
+    expected_blocks: list[FullBlock] = bt.get_consecutive_blocks(
+        request_length,
+        block_list_input=block_list_input,
+        time_per_block=time_per_block,
+        seed=seed,
+        skip_slots=empty_sub_slots,
+        normalized_to_identity_cc_eos=normalized_to_identity_cc_eos,
+        normalized_to_identity_icc_eos=normalized_to_identity_icc_eos,
+        normalized_to_identity_cc_sp=normalized_to_identity_cc_sp,
+        normalized_to_identity_cc_ip=normalized_to_identity_cc_ip,
+        dummy_block_references=dummy_block_references,
+        include_transactions=include_transactions,
+        genesis_timestamp=uint64(1234567890),
+    )
+    assert len(expected_blocks) - request_length == input_length
+    # if this assert fails, and changing the test chains was
+    # intentional, please also update the test chain cache.
+    # run: pytest -m build_test_chains
+    for i in range(input_length, len(expected_blocks)):
+        print(f"i: {i}")
+        if blocks[i] != expected_blocks[i]:  # pragma: no cover
+            print(
+                f"Block {i} in the block cache on disk differs "
+                "from what BlockTools generated. Please make sure "
+                "your test blocks are up-to-date"
+            )
+            print(f"disk:\n{blocks[i]}")
+            print(f"block-tools:\n{expected_blocks[i]}")
+        assert blocks[i] == expected_blocks[i]
+
+
+def test_validate_default_400(bt: BlockTools, default_400_blocks: list[FullBlock]) -> None:
+    validate_chain(bt, default_400_blocks, seed=b"400")
+
+
+def test_validate_default_1000(bt: BlockTools, default_1000_blocks: list[FullBlock]) -> None:
+    validate_chain(bt, default_1000_blocks, seed=b"1000")
+
+
+def test_validate_pre_genesis_empty_1000(bt: BlockTools, pre_genesis_empty_slots_1000_blocks: list[FullBlock]) -> None:
+    validate_chain(bt, pre_genesis_empty_slots_1000_blocks, seed=b"empty_slots", empty_sub_slots=1)
+
+
+def test_validate_default_1500(bt: BlockTools, default_1500_blocks: list[FullBlock]) -> None:
+    validate_chain(bt, default_1500_blocks, seed=b"1500")
+
+
+def test_validate_default_10000(
+    bt: BlockTools,
+    default_10000_blocks: list[FullBlock],
+) -> None:
+    validate_chain(
+        bt,
+        default_10000_blocks,
+        seed=b"10000",
+        dummy_block_references=True,
+    )
+
+
+def test_validate_default_2000_compact(bt: BlockTools, default_2000_blocks_compact: list[FullBlock]) -> None:
+    validate_chain(
+        bt,
+        default_2000_blocks_compact,
+        normalized_to_identity_cc_eos=True,
+        normalized_to_identity_icc_eos=True,
+        normalized_to_identity_cc_ip=True,
+        normalized_to_identity_cc_sp=True,
+        seed=b"2000_compact",
+    )
+
+
+def test_validate_default_10000_compact(bt: BlockTools, default_10000_blocks_compact: list[FullBlock]) -> None:
+    validate_chain(
+        bt,
+        default_10000_blocks_compact,
+        normalized_to_identity_cc_eos=True,
+        normalized_to_identity_icc_eos=True,
+        normalized_to_identity_cc_ip=True,
+        normalized_to_identity_cc_sp=True,
+        seed=b"1000_compact",
+    )
+
+
+def test_validate_long_reorg_blocks(
+    bt: BlockTools, test_long_reorg_blocks: list[FullBlock], default_10000_blocks: list[FullBlock]
+) -> None:
+    validate_chain(
+        bt,
+        test_long_reorg_blocks,
+        block_list_input=default_10000_blocks[:500],
+        seed=b"reorg_blocks",
+        time_per_block=8,
+        dummy_block_references=True,
+        include_transactions=True,
+    )
+
+
+def test_validate_long_reorg_blocks_light(
+    bt: BlockTools, test_long_reorg_blocks_light: list[FullBlock], default_10000_blocks: list[FullBlock]
+) -> None:
+    validate_chain(
+        bt,
+        test_long_reorg_blocks_light,
+        block_list_input=default_10000_blocks[:500],
+        seed=b"reorg_blocks2",
+        dummy_block_references=True,
+        include_transactions=True,
+    )
+
+
+def test_validate_long_reorg_1500_blocks(
+    bt: BlockTools, test_long_reorg_1500_blocks: list[FullBlock], default_10000_blocks: list[FullBlock]
+) -> None:
+    validate_chain(
+        bt,
+        test_long_reorg_1500_blocks,
+        block_list_input=default_10000_blocks[:1500],
+        seed=b"reorg_blocks",
+        time_per_block=8,
+        dummy_block_references=True,
+        include_transactions=True,
+    )
+
+
+def test_validate_long_reorg_1500_blocks_light(
+    bt: BlockTools, test_long_reorg_1500_blocks_light: list[FullBlock], default_10000_blocks: list[FullBlock]
+) -> None:
+    validate_chain(
+        bt,
+        test_long_reorg_1500_blocks_light,
+        block_list_input=default_10000_blocks[:1500],
+        seed=b"reorg_blocks2",
+        dummy_block_references=True,
+        include_transactions=True,
+    )

chia/_tests/blockchain/test_get_block_generator.py

@@ -6,11 +6,11 @@ from typing import Optional
 import pytest
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
-from clvm.casts import int_to_bytes
 
 from chia.consensus.get_block_generator import get_block_generator
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.generator_types import BlockGenerator
+from chia.util.casts import int_to_bytes
 
 
 @dataclass(frozen=True)

chia/_tests/blockchain/test_lookup_fork_chain.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 from dataclasses import dataclass
 
 import pytest
+from chia_rs import BlockRecord
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
 from chia._tests.util.benchmarks import rand_hash
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.consensus.find_fork_point import find_fork_point_in_chain, lookup_fork_chain
 from chia.simulator.block_tools import test_constants

chia/_tests/clvm/benchmark_costs.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from chia_rs import SpendBundle
 from chia_rs.sized_ints import uint64
 
 from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
@@ -8,7 +9,6 @@ from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bundle_tools import simple_solution_generator
 from chia.types.blockchain_format.program import INFINITE_COST
 from chia.types.generator_types import BlockGenerator
-from chia.types.spend_bundle import SpendBundle
 
 
 def cost_of_spend_bundle(spend_bundle: SpendBundle) -> int:

chia/_tests/clvm/coin_store.py

@@ -5,17 +5,16 @@ from collections.abc import Iterator
 from dataclasses import dataclass, replace
 from typing import Optional
 
-from chia_rs import ConsensusConstants
+from chia_rs import ConsensusConstants, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
+from chia.consensus.check_time_locks import check_time_locks
 from chia.consensus.cost_calculator import NPCResult
 from chia.full_node.bundle_tools import simple_solution_generator
-from chia.full_node.mempool_check_conditions import mempool_check_time_locks
 from chia.types.blockchain_format.coin import Coin
 from chia.types.coin_record import CoinRecord
-from chia.types.spend_bundle import SpendBundle
 from chia.util.errors import Err
 
 MAX_COST = 11000000000
@@ -84,7 +83,7 @@ class CoinStore:
                     uint64(now.seconds),
                 )
 
-        err = mempool_check_time_locks(
+        err = check_time_locks(
             ephemeral_db,
             result.conds,
             # TODO: this is technically not right, it's supposed to be the

chia/_tests/clvm/test_message_conditions.py

@@ -129,13 +129,13 @@ def test_message_error_conditions() -> None:
             mode_integer=uint8(0b111),
         ).necessary_args
 
-    with pytest.raises(ValueError, match="Must specify either mode_integer or both sender and reciever"):
+    with pytest.raises(ValueError, match="Must specify either mode_integer or both sender and receiver"):
         SendMessage(
             msg=b"foo",
             sender=MessageParticipant(coin_id_committed=test_coin.name()),
         )
 
-    with pytest.raises(ValueError, match="Must specify either mode_integer or both sender and reciever"):
+    with pytest.raises(ValueError, match="Must specify either mode_integer or both sender and receiver"):
         SendMessage(
             msg=b"foo",
             receiver=MessageParticipant(coin_id_committed=test_coin.name()),

chia/_tests/clvm/test_puzzle_compression.py

@@ -5,14 +5,13 @@ from dataclasses import dataclass
 from typing import Callable, SupportsBytes
 
 import pytest
-from chia_rs import G1Element, G2Element
+from chia_rs import CoinSpend, G1Element, G2Element, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_spend import CoinSpend, make_spend
-from chia.types.spend_bundle import SpendBundle
+from chia.types.coin_spend import make_spend
 from chia.wallet.cat_wallet.cat_utils import CAT_MOD, construct_cat_puzzle
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_for_pk
 from chia.wallet.trading.offer import OFFER_MOD

chia/_tests/clvm/test_puzzles.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Iterable
 
-from chia_rs import AugSchemeMPL, G1Element
+from chia_rs import AugSchemeMPL, G1Element, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
@@ -12,7 +12,6 @@ from chia._tests.util.key_tool import KeyTool
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.program import Program
 from chia.types.coin_spend import make_spend
-from chia.types.spend_bundle import SpendBundle
 from chia.util.hash import std_hash
 from chia.wallet.puzzles import (
     p2_conditions,

chia/_tests/clvm/test_singletons.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Optional
 
 import pytest
-from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, CoinSpend, G1Element, G2Element, PrivateKey, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
@@ -13,9 +13,8 @@ from chia._tests.util.spend_sim import CostLogger, SimClient, SpendSim, sim_and_
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
-from chia.types.spend_bundle import SpendBundle
 from chia.util.errors import Err
 from chia.wallet.lineage_proof import LineageProof
 from chia.wallet.puzzles import p2_conditions, p2_delegated_puzzle_or_hidden_puzzle

chia/_tests/clvm/test_spend_sim.py

@@ -1,20 +1,20 @@
 from __future__ import annotations
 
 import pytest
-from chia_rs import G2Element
+from chia_rs import G2Element, SpendBundle
 from chia_rs.sized_bytes import bytes32
 
 from chia._tests.util.spend_sim import sim_and_client
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_spend import compute_additions, make_spend
+from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
-from chia.types.spend_bundle import SpendBundle
+from chia.wallet.util.compute_additions import compute_additions
 
 
 @pytest.mark.anyio
 async def test_farming():
     async with sim_and_client(pass_prefarm=False) as (sim, _):
-        for i in range(0, 5):
+        for i in range(5):
             await sim.farm_block()
 
         assert len(sim.blocks) == 5
@@ -25,7 +25,7 @@ async def test_farming():
 @pytest.mark.anyio
 async def test_rewind():
     async with sim_and_client() as (sim, _):
-        for i in range(0, 5):
+        for i in range(5):
             await sim.farm_block()
 
         save_height = sim.get_height()
@@ -39,11 +39,11 @@ async def test_rewind():
 @pytest.mark.anyio
 async def test_all_endpoints():
     async with sim_and_client() as (sim, sim_client):
-        for i in range(0, 5):
+        for i in range(5):
             await sim.farm_block()
         await sim.farm_block(bytes32.zeros)
         await sim.farm_block(bytes32([1] * 32))
-        for i in range(0, 5):
+        for i in range(5):
             await sim.farm_block()
 
         # get_coin_records_by_hint

chia/_tests/cmds/cmd_test_utils.py

@@ -7,23 +7,20 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Optional, Union, cast
 
-from chia_rs import Coin, G2Element
+from chia_rs import BlockRecord, Coin, G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 
 import chia.cmds.wallet_funcs
 from chia._tests.cmds.testing_classes import create_test_block_record
-from chia._tests.cmds.wallet.test_consts import STD_TX, STD_UTX
+from chia._tests.cmds.wallet.test_consts import STD_TX, STD_UTX, get_bytes32
 from chia.cmds.chia import cli as chia_cli
 from chia.cmds.cmds_util import _T_RpcClient, node_config_section_names
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.rpc.data_layer_rpc_client import DataLayerRpcClient
-from chia.rpc.farmer_rpc_client import FarmerRpcClient
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.data_layer.data_layer_rpc_client import DataLayerRpcClient
+from chia.farmer.farmer_rpc_client import FarmerRpcClient
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 from chia.rpc.rpc_client import RpcClient
-from chia.rpc.wallet_request_types import GetSyncStatusResponse, SendTransactionMultiResponse
-from chia.rpc.wallet_rpc_client import WalletRpcClient
 from chia.simulator.simulator_full_node_rpc_client import SimulatorFullNodeRpcClient
 from chia.types.coin_record import CoinRecord
 from chia.types.signing_mode import SigningMode
@@ -36,6 +33,15 @@ from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.transaction_type import TransactionType
 from chia.wallet.util.tx_config import CoinSelectionConfig, TXConfig
 from chia.wallet.util.wallet_types import WalletType
+from chia.wallet.wallet_request_types import (
+    GetSyncStatusResponse,
+    NFTCalculateRoyalties,
+    NFTCalculateRoyaltiesResponse,
+    NFTGetInfo,
+    NFTGetInfoResponse,
+    SendTransactionMultiResponse,
+)
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 # Any functions that are the same for every command being tested should be below.
@@ -151,16 +157,14 @@ class TestWalletRpcClient(TestRpcClient):
         if bytes32([1] * 32), return (uint32(2), "test1"), if bytes32([1] * 32), return (uint32(3), "test2")
         """
         self.add_to_log("cat_asset_id_to_name", (asset_id,))
-        if asset_id == bytes32([1] * 32):
-            return uint32(2), "test1"
-        elif asset_id == bytes32([2] * 32):
-            return uint32(3), "test2"
-        else:
-            return None
+        for i in range(256):
+            if asset_id == get_bytes32(i):
+                return uint32(i + 1), "test" + str(i)
+        return None
 
-    async def get_nft_info(self, coin_id: str, latest: bool = True) -> dict[str, Any]:
-        self.add_to_log("get_nft_info", (coin_id, latest))
-        coin_id_bytes = bytes32.fromhex(coin_id)
+    async def get_nft_info(self, request: NFTGetInfo) -> NFTGetInfoResponse:
+        self.add_to_log("get_nft_info", (request.coin_id, request.latest))
+        coin_id_bytes = bytes32.fromhex(request.coin_id)
         nft_info = NFTInfo(
             nft_id=encode_puzzle_hash(coin_id_bytes, "nft"),
             launcher_id=bytes32([1] * 32),
@@ -183,17 +187,18 @@ class TestWalletRpcClient(TestRpcClient):
             supports_did=True,
             p2_address=bytes32([8] * 32),
         )
-        return {"nft_info": nft_info.to_json_dict()}
+        return NFTGetInfoResponse(nft_info)
 
     async def nft_calculate_royalties(
         self,
-        royalty_assets_dict: dict[Any, tuple[Any, uint16]],
-        fungible_asset_dict: dict[Any, uint64],
-    ) -> dict[Any, list[dict[str, Any]]]:
-        self.add_to_log("nft_calculate_royalties", (royalty_assets_dict, fungible_asset_dict))
-        return NFTWallet.royalty_calculation(
-            royalty_assets_dict=royalty_assets_dict,
-            fungible_asset_dict=fungible_asset_dict,
+        request: NFTCalculateRoyalties,
+    ) -> NFTCalculateRoyaltiesResponse:
+        self.add_to_log("nft_calculate_royalties", (request,))
+        return NFTCalculateRoyaltiesResponse.from_json_dict(
+            NFTWallet.royalty_calculation(
+                {asset.asset: (asset.royalty_address, asset.royalty_percentage) for asset in request.royalty_assets},
+                {asset.asset: asset.amount for asset in request.fungible_assets},
+            )
         )
 
     async def get_spendable_coins(

chia/_tests/cmds/test_dev_gh.py

@@ -14,7 +14,7 @@ from _pytest.capture import CaptureFixture
 
 import chia._tests
 from chia._tests.util.misc import Marks, datacases
-from chia.cmds.gh import Per, TestCMD, get_gh_token
+from chia.cmds.dev.gh import Per, TestCMD, get_gh_token
 
 test_root = Path(chia._tests.__file__).parent
 

chia/_tests/cmds/test_farm_cmd.py

@@ -9,9 +9,9 @@ from chia._tests.util.time_out_assert import time_out_assert
 from chia.cmds.farm_funcs import summary
 from chia.farmer.farmer import Farmer
 from chia.harvester.harvester import Harvester
+from chia.server.aliases import FarmerService, HarvesterService, WalletService
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.start_simulator import SimulatorFullNodeService
-from chia.types.aliases import FarmerService, HarvesterService, WalletService
 
 
 @pytest.mark.anyio

chia/_tests/cmds/test_show.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Optional
 
-from chia_rs import FoliageTransactionBlock
+from chia_rs import FoliageTransactionBlock, FullBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
@@ -12,7 +12,6 @@ from chia._tests.cmds.cmd_test_utils import TestFullNodeRpcClient, TestRpcClient
 from chia._tests.cmds.testing_classes import hash_to_height, height_hash
 from chia._tests.util.test_full_block_utils import get_foliage, get_reward_chain_block, get_transactions_info, vdf_proof
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.full_block import FullBlock
 
 
 @dataclass