chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/core/full_node/test_generator_tools.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.spend_bundle_conditions import SpendBundleConditions, SpendConditions
+from chia.util.generator_tools import tx_removals_and_additions
+from chia.util.hash import std_hash
+from chia.util.ints import uint32, uint64
+
+coin_ids = [std_hash(i.to_bytes(4, "big")) for i in range(10)]
+parent_ids = [std_hash(i.to_bytes(4, "big")) for i in range(10)]
+phs = [std_hash(i.to_bytes(4, "big")) for i in range(10)]
+spends: list[SpendConditions] = [
+    SpendConditions(
+        coin_ids[0],
+        parent_ids[0],
+        phs[0],
+        123,
+        None,
+        uint64(5),
+        None,
+        None,
+        None,
+        None,
+        [
+            (phs[2], uint64(123), b""),
+            (phs[3], uint64(0), b"1" * 300),
+            (phs[4], uint64(0), b"1" * 300),
+        ],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        0,
+    ),
+    SpendConditions(
+        coin_ids[1],
+        parent_ids[1],
+        phs[0],
+        123,
+        None,
+        uint64(2),
+        None,
+        None,
+        None,
+        None,
+        [
+            (phs[5], uint64(123), b""),
+            (phs[6], uint64(0), b"1" * 300),
+            (phs[7], uint64(0), b"1" * 300),
+        ],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        0,
+    ),
+]
+
+
+def test_tx_removals_and_additions() -> None:
+    conditions = SpendBundleConditions(
+        spends, uint64(0), uint32(0), uint64(0), None, None, [], uint64(0), 0, 0, False, 0, 0
+    )
+    expected_rems = [coin_ids[0], coin_ids[1]]
+    expected_additions = []
+    for spend in spends:
+        for puzzle_hash, am, _ in spend.create_coin:
+            expected_additions.append(Coin(bytes32(spend.coin_id), bytes32(puzzle_hash), uint64(am)))
+    rems, adds = tx_removals_and_additions(conditions)
+    assert rems == expected_rems
+    assert adds == expected_additions
+
+
+def test_empty_conditions() -> None:
+    assert tx_removals_and_additions(None) == ([], [])

chia/_tests/core/full_node/test_hint_management.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import pytest
+
+from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
+from chia.consensus.block_record import BlockRecord
+from chia.consensus.blockchain import Blockchain, StateChangeSummary
+from chia.full_node.hint_management import get_hints_and_subscription_coin_ids
+from chia.simulator.block_tools import BlockTools
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.hash import std_hash
+from chia.util.ints import uint32, uint64
+
+coin_ids = [std_hash(i.to_bytes(4, "big")) for i in range(10)]
+parent_ids = [std_hash(i.to_bytes(4, "big")) for i in range(10)]
+phs = [std_hash(i.to_bytes(4, "big")) for i in range(10)]
+removals = [(coin_ids[0], phs[0]), (coin_ids[2], phs[0]), (coin_ids[1], phs[7])]
+additions = [
+    (Coin(coin_ids[0], phs[2], uint64(123)), None),
+    (Coin(coin_ids[0], phs[4], uint64(3)), b"1" * 32),
+    (Coin(coin_ids[2], phs[7], uint64(123)), None),
+    (Coin(coin_ids[2], phs[4], uint64(6)), None),
+    (Coin(coin_ids[2], phs[9], uint64(123)), b"1" * 32),
+    (Coin(coin_ids[1], phs[5], uint64(123)), None),
+    (Coin(coin_ids[1], phs[6], uint64(5)), b"1" * 3),
+]
+
+
+def no_sub(c: bytes32) -> bool:
+    return False
+
+
+@pytest.mark.anyio
+async def test_hints_to_add(bt: BlockTools, empty_blockchain: Blockchain) -> None:
+    blocks = bt.get_consecutive_blocks(2)
+    await _validate_and_add_block(empty_blockchain, blocks[0])
+    await _validate_and_add_block(empty_blockchain, blocks[1])
+    br: Optional[BlockRecord] = empty_blockchain.get_peak()
+    assert br is not None
+
+    scs = StateChangeSummary(br, uint32(0), [], removals, additions, [])
+    hints_to_add, lookup_coin_ids = get_hints_and_subscription_coin_ids(scs, no_sub, no_sub)
+    assert len(lookup_coin_ids) == 0
+
+    first_coin_id: bytes32 = Coin(bytes32(coin_ids[0]), bytes32(phs[4]), uint64(3)).name()
+    second_coin_id: bytes32 = Coin(bytes32(coin_ids[1]), bytes32(phs[6]), uint64(5)).name()
+    third_coin_id: bytes32 = Coin(bytes32(coin_ids[2]), bytes32(phs[9]), uint64(123)).name()
+    assert set(hints_to_add) == {(first_coin_id, b"1" * 32), (second_coin_id, b"1" * 3), (third_coin_id, b"1" * 32)}
+
+
+@pytest.mark.anyio
+async def test_lookup_coin_ids(bt: BlockTools, empty_blockchain: Blockchain) -> None:
+    blocks = bt.get_consecutive_blocks(2)
+    await _validate_and_add_block(empty_blockchain, blocks[0])
+    await _validate_and_add_block(empty_blockchain, blocks[1])
+    br: Optional[BlockRecord] = empty_blockchain.get_peak()
+    assert br is not None
+
+    rewards: list[Coin] = [
+        Coin(coin_ids[8], phs[8], uint64(1)),
+        Coin(coin_ids[9], phs[9], uint64(2)),
+        Coin(coin_ids[5], phs[8], uint64(1234)),
+    ]
+    scs = StateChangeSummary(br, uint32(0), [], removals, additions, rewards)
+
+    # Removal ID and addition PH
+    has_coin_sub = lambda c: c == coin_ids[1]  # noqa: E731
+    has_ph_sub = lambda ph: ph == phs[4]  # noqa: E731
+
+    _, lookup_coin_ids = get_hints_and_subscription_coin_ids(scs, has_coin_sub, has_ph_sub)
+
+    first_coin_id: bytes32 = Coin(bytes32(coin_ids[0]), bytes32(phs[4]), uint64(3)).name()
+    second_coin_id: bytes32 = Coin(bytes32(coin_ids[2]), bytes32(phs[4]), uint64(6)).name()
+    assert set(lookup_coin_ids) == {coin_ids[1], first_coin_id, second_coin_id}
+
+    # Removal PH and addition ID
+    has_coin_sub = lambda c: c == first_coin_id  # noqa: E731
+    has_ph_sub = lambda ph: ph == phs[0]  # noqa: E731
+
+    _, lookup_coin_ids = get_hints_and_subscription_coin_ids(scs, has_coin_sub, has_ph_sub)
+    assert set(lookup_coin_ids) == {first_coin_id, coin_ids[0], coin_ids[2]}
+
+    # Subscribe to hint
+    third_coin_id: bytes32 = Coin(bytes32(coin_ids[2]), phs[9], uint64(123)).name()
+
+    has_ph_sub = lambda ph: ph == bytes32(b"1" * 32)  # noqa: E731
+
+    _, lookup_coin_ids = get_hints_and_subscription_coin_ids(scs, no_sub, has_ph_sub)
+    assert set(lookup_coin_ids) == {first_coin_id, third_coin_id}
+
+    # Reward PH
+    has_ph_sub = lambda ph: ph == rewards[0].puzzle_hash  # noqa: E731
+
+    _, lookup_coin_ids = get_hints_and_subscription_coin_ids(scs, no_sub, has_ph_sub)
+    assert set(lookup_coin_ids) == {rewards[0].name(), rewards[2].name()}
+
+    # Reward coin id + reward ph
+    has_coin_sub = lambda c: c == rewards[1].name()  # noqa: E731
+
+    _, lookup_coin_ids = get_hints_and_subscription_coin_ids(scs, has_coin_sub, has_ph_sub)
+    assert set(lookup_coin_ids) == {rewards[1].name(), rewards[0].name(), rewards[2].name()}

chia/_tests/core/full_node/test_node_load.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import pytest
+
+from chia._tests.core.node_height import node_height_at_least
+from chia._tests.util.misc import BenchmarkRunner
+from chia._tests.util.time_out_assert import time_out_assert
+from chia.types.peer_info import PeerInfo
+
+
+class TestNodeLoad:
+    @pytest.mark.anyio
+    async def test_blocks_load(self, two_nodes, self_hostname, benchmark_runner: BenchmarkRunner):
+        num_blocks = 50
+        full_node_1, full_node_2, server_1, server_2, bt = two_nodes
+        blocks = bt.get_consecutive_blocks(num_blocks)
+        await full_node_1.full_node.add_block(blocks[0])
+        await time_out_assert(10, node_height_at_least, True, full_node_1, 0)
+        await server_2.start_client(
+            PeerInfo(self_hostname, server_1.get_port()), on_connect=full_node_2.full_node.on_connect
+        )
+
+        async def num_connections():
+            return len(server_2.get_connections())
+
+        await time_out_assert(10, num_connections, 1)
+        await time_out_assert(10, node_height_at_least, True, full_node_2, 0)
+
+        with benchmark_runner.assert_runtime(seconds=100) as runtime_results_future:
+            for i in range(1, num_blocks):
+                await full_node_1.full_node.add_block(blocks[i])
+                await full_node_2.full_node.add_block(blocks[i])
+        runtime_results = runtime_results_future.result(timeout=0)
+        print(f"Time taken to process {num_blocks} is {runtime_results.duration}")

chia/_tests/core/full_node/test_performance.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import logging
+import random
+
+import pytest
+from clvm.casts import int_to_bytes
+
+from chia._tests.connection_utils import add_dummy_connection
+from chia._tests.core.full_node.stores.test_coin_store import get_future_reward_coins
+from chia._tests.core.node_height import node_height_at_least
+from chia._tests.util.misc import BenchmarkRunner
+from chia._tests.util.time_out_assert import time_out_assert
+from chia.consensus.block_record import BlockRecord
+from chia.consensus.pot_iterations import is_overflow_block
+from chia.full_node.full_node_api import FullNodeAPI
+from chia.protocols import full_node_protocol as fnp
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.types.condition_with_args import ConditionWithArgs
+from chia.types.unfinished_block import UnfinishedBlock
+from chia.util.ints import uint64
+
+log = logging.getLogger(__name__)
+
+
+async def get_block_path(full_node: FullNodeAPI):
+    blocks_list = [await full_node.full_node.blockchain.get_full_peak()]
+    assert blocks_list[0] is not None
+    while blocks_list[0].height != 0:
+        b = await full_node.full_node.block_store.get_full_block(blocks_list[0].prev_header_hash)
+        assert b is not None
+        blocks_list.insert(0, b)
+    return blocks_list
+
+
+class TestPerformance:
+    @pytest.mark.anyio
+    async def test_full_block_performance(
+        self, request: pytest.FixtureRequest, wallet_nodes_perf, self_hostname, benchmark_runner: BenchmarkRunner
+    ):
+        full_node_1, server_1, wallet_a, wallet_receiver, bt = wallet_nodes_perf
+        blocks = await full_node_1.get_all_full_blocks()
+        full_node_1.full_node.mempool_manager.limit_factor = 1
+
+        wallet_ph = wallet_a.get_new_puzzlehash()
+        blocks = bt.get_consecutive_blocks(
+            10,
+            block_list_input=blocks,
+            guarantee_transaction_block=True,
+            farmer_reward_puzzle_hash=wallet_ph,
+            pool_reward_puzzle_hash=wallet_ph,
+        )
+        for block in blocks:
+            await full_node_1.full_node.add_block(block)
+
+        start_height = (
+            full_node_1.full_node.blockchain.get_peak().height
+            if full_node_1.full_node.blockchain.get_peak() is not None
+            else -1
+        )
+        _incoming_queue, node_id = await add_dummy_connection(server_1, self_hostname, 12312)
+        fake_peer = server_1.all_connections[node_id]
+        # Mempool has capacity of 100, make 110 unspents that we can use
+        puzzle_hashes = []
+
+        # Makes a bunch of coins
+        for i in range(20):
+            conditions_dict: dict = {ConditionOpcode.CREATE_COIN: []}
+            # This should fit in one transaction
+            for _ in range(100):
+                receiver_puzzlehash = wallet_receiver.get_new_puzzlehash()
+                puzzle_hashes.append(receiver_puzzlehash)
+                output = ConditionWithArgs(ConditionOpcode.CREATE_COIN, [receiver_puzzlehash, int_to_bytes(100000000)])
+
+                conditions_dict[ConditionOpcode.CREATE_COIN].append(output)
+
+            spend_bundle = wallet_a.generate_signed_transaction(
+                100,
+                puzzle_hashes[0],
+                get_future_reward_coins(blocks[1 + i])[0],
+                condition_dic=conditions_dict,
+            )
+            assert spend_bundle is not None
+
+            respond_transaction_2 = fnp.RespondTransaction(spend_bundle)
+            await full_node_1.respond_transaction(respond_transaction_2, fake_peer)
+
+            blocks = bt.get_consecutive_blocks(
+                1,
+                block_list_input=blocks,
+                guarantee_transaction_block=True,
+                transaction_data=spend_bundle,
+            )
+            await full_node_1.full_node.add_block(blocks[-1], fake_peer)
+
+        await time_out_assert(20, node_height_at_least, True, full_node_1, start_height + 20)
+
+        spend_bundles = []
+        spend_bundle_ids = []
+
+        # Fill mempool
+        for puzzle_hash in puzzle_hashes[1:]:
+            coin_record = (await full_node_1.full_node.coin_store.get_coin_records_by_puzzle_hash(True, puzzle_hash))[0]
+            receiver_puzzlehash = wallet_receiver.get_new_puzzlehash()
+            if puzzle_hash == puzzle_hashes[-1]:
+                fee = 100000000  # 100 million (20 fee per cost)
+            else:
+                fee = random.randint(1, 100000000)
+            spend_bundle = wallet_receiver.generate_signed_transaction(
+                uint64(500), receiver_puzzlehash, coin_record.coin, fee=fee
+            )
+            spend_bundles.append(spend_bundle)
+            spend_bundle_ids.append(spend_bundle.get_hash())
+
+        with benchmark_runner.assert_runtime(seconds=0.0055, label="mempool"):
+            num_tx: int = 0
+            for spend_bundle, spend_bundle_id in zip(spend_bundles, spend_bundle_ids):
+                num_tx += 1
+                respond_transaction = fnp.RespondTransaction(spend_bundle)
+
+                await full_node_1.respond_transaction(respond_transaction, fake_peer)
+
+                request_transaction = fnp.RequestTransaction(spend_bundle_id)
+                req = await full_node_1.request_transaction(request_transaction)
+
+                if req is None:
+                    break
+
+        log.warning(f"Num Tx: {num_tx}")
+
+        # Create an unfinished block
+        peak = full_node_1.full_node.blockchain.get_peak()
+        assert peak is not None
+        curr: BlockRecord = peak
+        while not curr.is_transaction_block:
+            curr = full_node_1.full_node.blockchain.block_record(curr.prev_hash)
+        mempool_bundle = await full_node_1.full_node.mempool_manager.create_bundle_from_mempool(
+            curr.header_hash, full_node_1.full_node.coin_store.get_unspent_lineage_info_for_puzzle_hash
+        )
+        if mempool_bundle is None:
+            spend_bundle = None
+        else:
+            spend_bundle = mempool_bundle[0]
+
+        current_blocks = await full_node_1.get_all_full_blocks()
+        blocks = bt.get_consecutive_blocks(
+            1,
+            transaction_data=spend_bundle,
+            block_list_input=current_blocks,
+            guarantee_transaction_block=True,
+        )
+        block = blocks[-1]
+        if is_overflow_block(bt.constants, block.reward_chain_block.signage_point_index):
+            sub_slots = block.finished_sub_slots[:-1]
+        else:
+            sub_slots = block.finished_sub_slots
+        unfinished = UnfinishedBlock(
+            sub_slots,
+            block.reward_chain_block.get_unfinished(),
+            block.challenge_chain_sp_proof,
+            block.reward_chain_sp_proof,
+            block.foliage,
+            block.foliage_transaction_block,
+            block.transactions_info,
+            block.transactions_generator,
+            [],
+        )
+
+        with benchmark_runner.assert_runtime(seconds=0.1, label="unfinished"):
+            res = await full_node_1.respond_unfinished_block(fnp.RespondUnfinishedBlock(unfinished), fake_peer)
+
+        log.warning(f"Res: {res}")
+
+        with benchmark_runner.assert_runtime(seconds=0.1, label="full block"):
+            # No transactions generator, the full node already cached it from the unfinished block
+            block_small = block.replace(transactions_generator=None)
+            res = await full_node_1.full_node.add_block(block_small)
+
+        log.warning(f"Res: {res}")