chia-blockchain 2.5.1rc1__py3-none-any.whl

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

chia/_tests/cmds/test_tx_config_args.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Optional
+
+import click
+from click.testing import CliRunner
+
+from chia.cmds.cmds_util import CMDCoinSelectionConfigLoader, CMDTXConfigLoader, coin_selection_args, tx_config_args
+from chia.cmds.param_types import CliAmount
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.config import create_default_chia_config, load_config
+
+
+def test_coin_selection_args() -> None:
+    @click.command()
+    @coin_selection_args
+    def test_cmd(
+        min_coin_amount: CliAmount,
+        max_coin_amount: CliAmount,
+        coins_to_exclude: Sequence[bytes32],
+        amounts_to_exclude: Sequence[CliAmount],
+    ) -> None:
+        print(
+            CMDCoinSelectionConfigLoader(
+                min_coin_amount,
+                max_coin_amount,
+                list(amounts_to_exclude),
+                list(coins_to_exclude),
+            )
+            .to_coin_selection_config(1)
+            .to_json_dict()
+        )
+
+    runner = CliRunner()
+
+    result = runner.invoke(
+        test_cmd,
+        [
+            "--min-coin-amount",
+            "0.0",
+            "--max-coin-amount",
+            "0.0",
+            "--exclude-coin",
+            "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "--exclude-amount",
+            "0.0",
+        ],
+        catch_exceptions=False,
+    )
+
+    assert (
+        r"{'min_coin_amount': 0, 'max_coin_amount': 0, 'excluded_coin_amounts': [0], 'excluded_coin_ids': "
+        r"['0x0000000000000000000000000000000000000000000000000000000000000000']}" in result.output
+    )
+
+    result = runner.invoke(
+        test_cmd,
+        [
+            "--exclude-coin",
+            "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "--exclude-coin",
+            "0x1111111111111111111111111111111111111111111111111111111111111111",
+            "--exclude-amount",
+            "0.0",
+            "--exclude-amount",
+            "1.0",
+        ],
+        catch_exceptions=False,
+    )
+
+    assert (
+        r"{'min_coin_amount': 0, 'max_coin_amount': 18446744073709551615, 'excluded_coin_amounts': [0, 1], "
+        r"'excluded_coin_ids': ['0x0000000000000000000000000000000000000000000000000000000000000000', "
+        r"'0x1111111111111111111111111111111111111111111111111111111111111111']}" in result.output
+    )
+
+    result = runner.invoke(
+        test_cmd,
+        [],
+        catch_exceptions=False,
+    )
+
+    assert (
+        r"{'min_coin_amount': 0, 'max_coin_amount': 18446744073709551615, 'excluded_coin_amounts': [], "
+        r"'excluded_coin_ids': []}" in result.output
+    )
+
+
+def test_tx_config_args() -> None:
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        create_default_chia_config(Path("."))
+        config = load_config(Path("."), "config.yaml")
+        config["reuse_public_key_for_change"] = {"1234567890": True}
+
+        @click.command()
+        @tx_config_args
+        def test_cmd(
+            min_coin_amount: CliAmount,
+            max_coin_amount: CliAmount,
+            coins_to_exclude: Sequence[bytes32],
+            amounts_to_exclude: Sequence[CliAmount],
+            reuse: Optional[bool],
+        ) -> None:
+            print(
+                CMDTXConfigLoader(
+                    min_coin_amount,
+                    max_coin_amount,
+                    list(amounts_to_exclude),
+                    list(coins_to_exclude),
+                    reuse,
+                )
+                .to_tx_config(1, config, 1234567890)
+                .to_json_dict()
+            )
+
+        result = runner.invoke(
+            test_cmd,
+            [
+                "--reuse-puzhash",
+            ],
+            catch_exceptions=False,
+        )
+
+        assert (
+            r"{'min_coin_amount': 0, 'max_coin_amount': 18446744073709551615, 'excluded_coin_amounts': [], "
+            r"'excluded_coin_ids': [], 'reuse_puzhash': True}" in result.output
+        )
+
+        result = runner.invoke(
+            test_cmd,
+            [
+                "--new-address",
+            ],
+            catch_exceptions=False,
+        )
+
+        assert (
+            r"{'min_coin_amount': 0, 'max_coin_amount': 18446744073709551615, 'excluded_coin_amounts': [], "
+            r"'excluded_coin_ids': [], 'reuse_puzhash': False}" in result.output
+        )
+
+        result = runner.invoke(
+            test_cmd,
+            [],
+            catch_exceptions=False,
+        )
+
+        assert (
+            r"{'min_coin_amount': 0, 'max_coin_amount': 18446744073709551615, 'excluded_coin_amounts': [], "
+            r"'excluded_coin_ids': [], 'reuse_puzhash': True}" in result.output
+        )

chia/_tests/cmds/testing_classes.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint8, uint32, uint64
+
+# This is a modified version of the TestBlockRecord from test_mempool_manager.py
+
+
+@dataclass(frozen=True)
+class TestBlockRecord:
+    """
+    This is a subset of BlockRecord that the cli tests need
+    """
+
+    header_hash: bytes32
+    height: uint32
+    timestamp: Optional[uint64]
+    prev_transaction_block_height: uint32
+    prev_transaction_block_hash: Optional[bytes32]
+    prev_hash: Optional[bytes32]
+    weight: uint64 = uint64(10000)
+    fees: uint64 = uint64(5000)
+    farmer_puzzle_hash: bytes32 = bytes32([1] * 32)
+    pool_puzzle_hash: bytes32 = bytes32([2] * 32)
+    sub_slot_iters: uint64 = uint64(1024)
+    total_iters: uint64 = uint64(12081)
+    deficit: uint8 = uint8(0)
+
+    @property
+    def is_transaction_block(self) -> bool:
+        return self.timestamp is not None
+
+
+def height_hash(height: int) -> bytes32:
+    return bytes32(height.to_bytes(32, byteorder="big"))
+
+
+def hash_to_height(int_bytes: bytes32) -> int:
+    return int.from_bytes(int_bytes, byteorder="big")
+
+
+def create_test_block_record(
+    *, height: uint32 = uint32(11), timestamp: uint64 = uint64(10040), header_hash: Optional[bytes32] = None
+) -> TestBlockRecord:
+    if header_hash is None:
+        header_hash = height_hash(height)
+    else:
+        height = uint32(hash_to_height(header_hash))  # so the heights make sense
+    return TestBlockRecord(
+        header_hash=header_hash,
+        height=height,
+        timestamp=timestamp,
+        prev_transaction_block_height=uint32(height - 1),
+        prev_transaction_block_hash=height_hash(height - 1),
+        prev_hash=height_hash(height - 1),
+    )

chia/_tests/cmds/wallet/test_consts.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from chia_rs import Coin, G2Element
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint32, uint64
+from chia.wallet.conditions import ConditionValidTimes
+from chia.wallet.signer_protocol import KeyHints, SigningInstructions, TransactionInfo, UnsignedTransaction
+from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.util.transaction_type import TransactionType
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+FINGERPRINT: str = "123456"
+FINGERPRINT_ARG: str = f"-f{FINGERPRINT}"
+CAT_FINGERPRINT: str = "789101"
+CAT_FINGERPRINT_ARG: str = f"-f{CAT_FINGERPRINT}"
+WALLET_ID: int = 1
+WALLET_ID_ARG: str = f"-i{WALLET_ID}"
+bytes32_hexstr = "0x6262626262626262626262626262626262626262626262626262626262626262"
+
+
+def get_bytes32(bytes_index: int) -> bytes32:
+    return bytes32([bytes_index] * 32)
+
+
+STD_TX = TransactionRecord(
+    confirmed_at_height=uint32(1),
+    created_at_time=uint64(1234),
+    to_puzzle_hash=get_bytes32(1),
+    amount=uint64(12345678),
+    fee_amount=uint64(1234567),
+    confirmed=False,
+    sent=uint32(0),
+    spend_bundle=WalletSpendBundle([], G2Element()),
+    additions=[Coin(get_bytes32(1), get_bytes32(2), uint64(12345678))],
+    removals=[Coin(get_bytes32(2), get_bytes32(4), uint64(12345678))],
+    wallet_id=uint32(1),
+    sent_to=[],
+    trade_id=None,
+    type=uint32(TransactionType.OUTGOING_TX.value),
+    name=get_bytes32(2),
+    memos=[(get_bytes32(3), [bytes([4] * 32)])],
+    valid_times=ConditionValidTimes(),
+)
+
+
+STD_UTX = UnsignedTransaction(TransactionInfo([]), SigningInstructions(KeyHints([], []), []))