chia-blockchain 2.4.4__py3-none-any.whl

chia/_tests/cmds/test_daemon.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import pytest
+from _pytest.capture import CaptureFixture
+from click.testing import CliRunner
+from pytest_mock import MockerFixture
+
+from chia.cmds.chia import cli
+from chia.cmds.start_funcs import create_start_daemon_connection, launch_start_daemon
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("skip_keyring", [False, True])
+@pytest.mark.parametrize("unlock_keyring", [False, True])
+async def test_daemon(
+    skip_keyring: bool, unlock_keyring: bool, mocker: MockerFixture, capsys: CaptureFixture[str]
+) -> None:
+    class DummyConnection:
+        @staticmethod
+        async def is_keyring_locked() -> bool:
+            return unlock_keyring
+
+        @staticmethod
+        async def unlock_keyring(_passphrase: str) -> bool:
+            return True
+
+    async def connect_to_daemon_and_validate(_root_path: Path, _config: Dict[str, Any]) -> DummyConnection:
+        return DummyConnection()
+
+    class DummyKeychain:
+        @staticmethod
+        def get_cached_master_passphrase() -> Optional[str]:
+            return None
+
+    def get_current_passphrase() -> Optional[str]:
+        return "a-passphrase"
+
+    mocker.patch("chia.cmds.start_funcs.connect_to_daemon_and_validate", side_effect=connect_to_daemon_and_validate)
+    mocker.patch("chia.cmds.start_funcs.Keychain", new=DummyKeychain)
+    mocker.patch("chia.cmds.start_funcs.get_current_passphrase", side_effect=get_current_passphrase)
+
+    daemon = await create_start_daemon_connection(Path("/path-not-exist"), {}, skip_keyring=skip_keyring)
+    assert daemon is not None
+    captured = capsys.readouterr()
+    assert captured.err == ""
+    if skip_keyring:
+        assert captured.out.endswith("Skipping to unlock keyring\n")
+    else:
+        assert not captured.out.endswith("Skipping to unlock keyring\n")
+
+
+@pytest.mark.anyio
+def test_launch_start_daemon(tmp_path: Path) -> None:
+    sys.argv[0] = "not-exist"
+    with pytest.raises(FileNotFoundError):
+        launch_start_daemon(tmp_path)
+
+    helper: Path = Path(sys.executable)
+    sys.argv[0] = str(helper.parent) + "/chia"
+    process = launch_start_daemon(tmp_path)
+    assert process is not None
+    process.kill()
+    process.wait()
+
+
+def test_start_daemon(tmp_path: Path, empty_keyring: Any, mocker: MockerFixture) -> None:
+    class DummyDaemon:
+        @staticmethod
+        async def close() -> None:
+            return None
+
+    async def create_start_daemon_connection_dummy(
+        root_path: Path, config: Dict[str, Any], *, skip_keyring: bool
+    ) -> DummyDaemon:
+        return DummyDaemon()
+
+    mocker.patch(
+        "chia.cmds.start_funcs.create_start_daemon_connection", side_effect=create_start_daemon_connection_dummy
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(
+        cli,
+        ["--root-path", str(tmp_path), "init"],
+    )
+    assert result.exit_code == 0
+    result = runner.invoke(cli, ["--root-path", str(tmp_path), "start", "daemon", "-s"])
+    assert result.exit_code == 0

chia/_tests/cmds/test_farm_cmd.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import re
+from typing import Tuple
+
+import pytest
+from _pytest.capture import CaptureFixture
+
+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.simulator.block_tools import BlockTools
+from chia.simulator.start_simulator import SimulatorFullNodeService
+from chia.types.aliases import FarmerService, HarvesterService, WalletService
+
+
+@pytest.mark.anyio
+async def test_farm_summary_command(
+    capsys: CaptureFixture[str],
+    farmer_one_harvester_simulator_wallet: Tuple[
+        HarvesterService,
+        FarmerService,
+        SimulatorFullNodeService,
+        WalletService,
+        BlockTools,
+    ],
+) -> None:
+    harvester_service, farmer_service, full_node_service, wallet_service, bt = farmer_one_harvester_simulator_wallet
+    harvester: Harvester = harvester_service._node
+    farmer: Farmer = farmer_service._node
+
+    async def receiver_available() -> bool:
+        return harvester.server.node_id in farmer.plot_sync_receivers
+
+    # Wait for the receiver to show up
+    await time_out_assert(20, receiver_available)
+    receiver = farmer.plot_sync_receivers[harvester.server.node_id]
+    # And wait until the first sync from the harvester to the farmer is done
+    await time_out_assert(20, receiver.initial_sync, False)
+
+    assert full_node_service.rpc_server and full_node_service.rpc_server.webserver
+    assert wallet_service.rpc_server and wallet_service.rpc_server.webserver
+    assert farmer_service.rpc_server and farmer_service.rpc_server.webserver
+
+    full_node_rpc_port = full_node_service.rpc_server.webserver.listen_port
+    wallet_rpc_port = wallet_service.rpc_server.webserver.listen_port
+    farmer_rpc_port = farmer_service.rpc_server.webserver.listen_port
+
+    await summary(full_node_rpc_port, wallet_rpc_port, None, farmer_rpc_port, bt.root_path)
+
+    captured = capsys.readouterr()
+    match = re.search(r"^.+(Farming status:.+)$", captured.out, re.DOTALL)
+    assert match is not None
+    lines = match.group(1).split("\n")
+
+    assert lines[0] == "Farming status: Not synced or not connected to peers"
+    assert "Total chia farmed:" in lines[1]
+    assert "User transaction fees:" in lines[2]
+    assert "Block rewards:" in lines[3]
+    assert "Last height farmed:" in lines[4]
+    assert lines[5] == "Local Harvester"
+    assert "e (effective)" in lines[6]
+    assert "Plot count for all harvesters:" in lines[7]
+    assert "e (effective)" in lines[8]
+    assert "Estimated network space:" in lines[9]
+    assert "Expected time to win:" in lines[10]

chia/_tests/cmds/test_show.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from chia._tests.cmds.cmd_test_utils import TestFullNodeRpcClient, TestRpcClients, run_cli_command_and_assert
+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.foliage import FoliageTransactionBlock
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.full_block import FullBlock
+from chia.util.ints import uint32, uint64
+
+
+@dataclass
+class ShowFullNodeRpcClient(TestFullNodeRpcClient):
+    async def get_fee_estimate(self, target_times: Optional[List[int]], cost: Optional[int]) -> Dict[str, Any]:
+        self.add_to_log("get_fee_estimate", (target_times, cost))
+        response: Dict[str, Any] = {
+            "current_fee_rate": 0,
+            "estimates": [0, 0, 0],
+            "fee_rate_last_block": 30769.681426718744,
+            "fees_last_block": 500000000000,
+            "full_node_synced": True,
+            "last_block_cost": 16249762,
+            "last_peak_timestamp": 1688858763,
+            "last_tx_block_height": 11,
+            "mempool_fees": 0,
+            "mempool_max_size": 0,
+            "mempool_size": 0,
+            "node_time_utc": 1689187617,
+            "num_spends": 0,
+            "peak_height": 11,
+            "success": True,
+            "target_times": target_times,
+        }
+        return response
+
+    async def get_block(self, header_hash: bytes32) -> Optional[FullBlock]:
+        # we return a block with the height matching the header hash
+        self.add_to_log("get_block", (header_hash,))
+        height = hash_to_height(header_hash)
+        foliage = None
+        for foliage in get_foliage():
+            break
+        assert foliage is not None
+        r_chain_block = None
+        for r_chain_block in get_reward_chain_block(height=uint32(height)):
+            break
+        assert r_chain_block is not None
+        foliage_tx_block = FoliageTransactionBlock(
+            prev_transaction_block_hash=height_hash(height - 1),
+            timestamp=uint64(100400000),
+            filter_hash=bytes32([2] * 32),
+            additions_root=bytes32([3] * 32),
+            removals_root=bytes32([4] * 32),
+            transactions_info_hash=bytes32([5] * 32),
+        )
+        tx_info = None
+        for tx_info in get_transactions_info(height=uint32(height), foliage_transaction_block=foliage_tx_block):
+            break
+        assert tx_info is not None
+        full_block = FullBlock(
+            finished_sub_slots=[],
+            reward_chain_block=r_chain_block,
+            challenge_chain_sp_proof=None,
+            challenge_chain_ip_proof=vdf_proof(),
+            reward_chain_sp_proof=None,
+            reward_chain_ip_proof=vdf_proof(),
+            infused_challenge_chain_ip_proof=None,
+            foliage=foliage,
+            foliage_transaction_block=foliage_tx_block,
+            transactions_info=tx_info,
+            transactions_generator=SerializedProgram.from_bytes(bytes.fromhex("ff01820539")),
+            transactions_generator_ref_list=[],
+        )
+        return full_block
+
+
+RPC_CLIENT_TO_USE = ShowFullNodeRpcClient()  # pylint: disable=no-value-for-parameter
+
+
+def test_chia_show(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+    test_rpc_clients, root_dir = get_test_cli_clients
+    # set RPC Client
+    test_rpc_clients.full_node_rpc_client = RPC_CLIENT_TO_USE
+    # get output with all options
+    command_args = [
+        "show",
+        "-s",
+        "-f",
+        "--block-header-hash-by-height",
+        "10",
+        "-b0x000000000000000000000000000000000000000000000000000000000000000b",
+    ]
+    # these are various things that should be in the output
+    assert_list = [
+        "Current Blockchain Status: Full Node Synced",
+        "Estimated network space: 25.647 EiB",
+        "Block fees: 500000000000 mojos",
+        "Fee rate:    3.077e+04 mojos per CLVM cost",
+        f"Tx Filter Hash         {bytes32([2] * 32).hex()}",
+        "Weight                 10000",
+        "Is a Transaction Block?True",
+    ]
+    run_cli_command_and_assert(capsys, root_dir, command_args, assert_list)
+    expected_calls: dict[str, Optional[List[tuple[Any, ...]]]] = {  # name of rpc: (args)
+        "get_blockchain_state": None,
+        "get_block_record": [(height_hash(height),) for height in [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 11, 10]],
+        "get_block_record_by_height": [(10,)],
+        "get_fee_estimate": [([60, 120, 300], 1)],
+        "get_block": [(height_hash(11),)],
+    }  # these RPC's should be called with these variables.
+    test_rpc_clients.full_node_rpc_client.check_log(expected_calls)

chia/_tests/cmds/test_sim.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from pathlib import Path
+from shutil import rmtree
+
+import pytest
+from click.testing import CliRunner
+
+from chia.cmds.chia import cli
+from chia.util.config import lock_and_load_config, save_config
+from chia.util.default_root import SIMULATOR_ROOT_PATH
+
+mnemonic = (  # ignore any secret warnings
+    "cup smoke miss park baby say island tomorrow segment lava bitter easily settle gift renew arrive kangaroo dilemma "
+    "organ skin design salt history awesome"
+)
+fingerprint = 2640131813
+std_farming_address = "txch1mh4qanzyawn3v4uphgaj2cg6hrjazwyp0sx653fhn9apg6mfajlqtj0ztp"
+burn_address = "txch1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqm6ksh7qddh"  # 0x0...dead
+
+SIMULATOR_ROOT_PATH.mkdir(parents=True, exist_ok=True)  # this simplifies code later
+
+
+def get_profile_path(starting_string: str) -> str:
+    """
+    Returns the name of a profile that does not exist yet.
+    """
+    i = 0
+    while Path(SIMULATOR_ROOT_PATH / (starting_string + str(i))).exists():
+        i += 1
+    return starting_string + str(i)
+
+
+@pytest.mark.skip("TODO: Fix this - hangs often in CI - root cause unknown")
+def test_every_simulator_command() -> None:
+    starting_str = "ci_test"
+    simulator_name = get_profile_path(starting_str)
+    runner: CliRunner = CliRunner()
+    address = std_farming_address
+    start_result = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "create", "-bm", mnemonic],
+        catch_exceptions=False,
+    )
+    assert start_result.exit_code == 0
+    assert f"Farming & Prefarm reward address: {address}" in start_result.output
+    assert "chia_full_node_simulator: started" in start_result.output
+    assert "Genesis block generated, exiting." in start_result.output
+
+    config_dir = SIMULATOR_ROOT_PATH.joinpath(simulator_name)
+    with lock_and_load_config(config_dir, "config.yaml") as config:
+        config["rpc_timeout"] = 600
+        save_config(config_dir, "config.yaml", config)
+
+    try:
+        # run all tests
+        run_all_tests(runner, address, simulator_name)
+    finally:
+        stop_simulator(runner, simulator_name)
+
+
+@pytest.mark.skip("Need to rewrite")
+def test_custom_farming_address() -> None:
+    runner: CliRunner = CliRunner()
+    address = burn_address
+    starting_str = "ci_address_test"
+    simulator_name = get_profile_path(starting_str)
+    start_result = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "create", "-bm", mnemonic, "--reward-address", address],
+        catch_exceptions=False,
+    )
+    assert start_result.exit_code == 0
+    assert f"Farming & Prefarm reward address: {address}" in start_result.output
+    assert "chia_full_node_simulator: started" in start_result.output
+    assert "Genesis block generated, exiting." in start_result.output
+
+    try:
+        # just run status test
+        _test_sim_status(runner, address, simulator_name)
+    finally:
+        stop_simulator(runner, simulator_name)
+
+
+def stop_simulator(runner: CliRunner, simulator_name: str) -> None:
+    """Stop simulator."""
+    result = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "stop", "-d"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    assert "chia_full_node_simulator: Stopped\nDaemon stopped\n" == result.output
+    rmtree(SIMULATOR_ROOT_PATH / simulator_name)
+
+
+def run_all_tests(runner: CliRunner, address: str, simulator_name: str) -> None:
+    """Run all tests."""
+    _test_sim_status(runner, address, simulator_name)
+    _test_farm_and_revert_block(runner, address, simulator_name)
+
+
+def _test_sim_status(runner: CliRunner, address: str, simulator_name: str) -> None:
+    # show everything
+    result = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "status", "--show-key", "-cia"],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0
+    # asserts are grouped by arg
+    assert (
+        f"Fingerprint: {fingerprint}" in result.output
+        and f"Mnemonic seed (24 secret words):\n{mnemonic}" in result.output
+    )  # -k
+
+    assert (
+        "Network: simulator0" in result.output and "Current Blockchain Status: Full Node Synced" in result.output
+    )  # default
+    assert "Height:          1" in result.output  # default
+    assert f"Current Farming address: {address}, with a balance of: 21000000.0 TXCH." in result.output  # default
+
+    assert (
+        f"Address: {address} has a balance of: 21000000000000000000 mojo, with a total of: 2 transactions."
+        in result.output
+    )  # -ia
+    assert "Coin Amount: 2625000000000000000 mojo" in result.output  # -ic
+
+
+def _test_farm_and_revert_block(runner: CliRunner, address: str, simulator_name: str) -> None:
+    # make 5 blocks
+    five_blocks_result = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "farm", "-b", "5", "-a", address],
+        catch_exceptions=False,
+    )
+    assert five_blocks_result.exit_code == 0
+    assert "Farmed 5 Transaction blocks" in five_blocks_result.output
+
+    # check that height increased
+    five_blocks_check = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "status"],
+        catch_exceptions=False,
+    )
+    assert five_blocks_check.exit_code == 0
+    assert "Height:          6" in five_blocks_check.output
+
+    # do a reorg, 3 blocks back, 2 blocks forward, height now 8
+    reorg_result = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "revert", "-b", "3", "-n", "2"],
+        catch_exceptions=False,
+    )
+    assert reorg_result.exit_code == 0
+    assert "Block: 3 and above " in reorg_result.output and "Block Height is now: 8" in reorg_result.output
+
+    # check that height changed by 2
+    reorg_check = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "status"],
+        catch_exceptions=False,
+    )
+    assert reorg_check.exit_code == 0
+    assert "Height:          8" in reorg_check.output
+
+    # do a forceful reorg 4 blocks back
+    forced_reorg_result = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "revert", "-b", "4", "-fd"],
+        catch_exceptions=False,
+    )
+    assert forced_reorg_result.exit_code == 0
+    assert (
+        "Block: 8 and above were successfully deleted" in forced_reorg_result.output
+        and "Block Height is now: 4" in forced_reorg_result.output
+    )
+
+    # check that height changed by 4
+    forced_reorg_check = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "status"],
+        catch_exceptions=False,
+    )
+    assert forced_reorg_check.exit_code == 0
+    assert "Height:          4" in forced_reorg_check.output
+
+    # test chain reset to genesis
+    genesis_reset_result = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "revert", "-fd", "--reset"],
+        catch_exceptions=False,
+    )
+    assert genesis_reset_result.exit_code == 0
+    assert (
+        "Block: 2 and above were successfully deleted" in genesis_reset_result.output
+        and "Block Height is now: 1" in genesis_reset_result.output
+    )
+
+    # check that height changed to 1
+    genesis_reset_check = runner.invoke(
+        cli,
+        ["dev", "sim", "-n", simulator_name, "status"],
+        catch_exceptions=False,
+    )
+    assert genesis_reset_check.exit_code == 0
+    assert "Height:          1" in genesis_reset_check.output

chia/_tests/cmds/test_timelock_args.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import click
+from click.testing import CliRunner
+
+from chia.cmds.cmds_util import timelock_args
+from chia.wallet.conditions import ConditionValidTimes
+
+
+def test_timelock_args() -> None:
+    @click.command()
+    @timelock_args(enable=True)
+    def test_cmd(condition_valid_times: ConditionValidTimes) -> None:
+        print(condition_valid_times.min_time)
+        print(condition_valid_times.max_time)
+
+    runner = CliRunner()
+
+    result = runner.invoke(
+        test_cmd,
+        [
+            "--valid-at",
+            "0",
+            "--expires-at",
+            "0",
+        ],
+        catch_exceptions=False,
+    )
+
+    assert "0\n0\n" == result.output
+
+    result = runner.invoke(
+        test_cmd,
+        [
+            "--valid-at",
+            "4294967295",
+            "--expires-at",
+            "4294967295",
+        ],
+        catch_exceptions=False,
+    )
+
+    assert "4294967295\n4294967295\n" == result.output
+
+    result = runner.invoke(
+        test_cmd,
+        [],
+        catch_exceptions=False,
+    )
+
+    assert "None\nNone\n" == result.output
+
+    # Test the hidden help
+    @click.command()
+    @timelock_args(enable=False)
+    def test_cmd_disabled(condition_valid_times: ConditionValidTimes) -> None:
+        print(condition_valid_times.min_time)
+        print(condition_valid_times.max_time)
+
+    result = runner.invoke(
+        test_cmd_disabled,
+        [],
+        catch_exceptions=False,
+    )
+
+    assert "None\nNone\n" == result.output
+
+    result = runner.invoke(
+        test_cmd_disabled,
+        ["--help"],
+        catch_exceptions=False,
+    )
+
+    assert "--valid-at" not in result.output
+    assert "--expires-at" not in result.output