chia-blockchain 2.5.2rc2__py3-none-any.whl → 2.5.3__py3-none-any.whl

chia/_tests/core/full_node/test_generator_tools.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
+
 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)]

chia/_tests/core/full_node/test_hint_management.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from typing import Optional
 
 import pytest
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
 from chia.consensus.block_record import BlockRecord
@@ -10,9 +12,7 @@ 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)]

chia/_tests/core/full_node/test_performance.py

@@ -4,6 +4,7 @@ import logging
 import random
 
 import pytest
+from chia_rs.sized_ints import uint64
 from clvm.casts import int_to_bytes
 
 from chia._tests.connection_utils import add_dummy_connection
@@ -13,26 +14,14 @@ 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(
@@ -134,9 +123,7 @@ class TestPerformance:
         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
-        )
+        mempool_bundle = await full_node_1.full_node.mempool_manager.create_bundle_from_mempool(curr.header_hash)
         if mempool_bundle is None:
             spend_bundle = None
         else:

chia/_tests/core/full_node/test_subscriptions.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from chia_rs import AugSchemeMPL, Coin, CoinSpend, G2Element, Program
+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
@@ -8,7 +9,6 @@ from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bundle_tools import simple_solution_generator
 from chia.full_node.subscriptions import PeerSubscriptions, peers_for_spend_bundle
 from chia.types.blockchain_format.program import INFINITE_COST
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.spend_bundle import SpendBundle
 
 IDENTITY_PUZZLE = Program.to(1)

chia/_tests/core/full_node/test_transactions.py

@@ -5,199 +5,200 @@ import random
 from typing import Optional
 
 import pytest
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32
 
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.peer_info import PeerInfo
-from chia.util.ints import uint32
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 
 
-class TestTransactions:
-    @pytest.mark.anyio
-    async def test_wallet_coinbase(self, simulator_and_wallet, self_hostname):
-        num_blocks = 5
-        full_nodes, wallets, _ = simulator_and_wallet
-        full_node_api = full_nodes[0]
-        full_node_server = full_node_api.server
-        wallet_node, server_2 = wallets[0]
-        wallet = wallet_node.wallet_state_manager.main_wallet
-        ph = await wallet.get_new_puzzlehash()
-
-        await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-        for i in range(num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-
-        funds = sum(
-            calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)
-        )
-        # funds += calculate_base_farmer_reward(0)
-        await asyncio.sleep(2)
-        print(await wallet.get_confirmed_balance(), funds)
-        await time_out_assert(20, wallet.get_confirmed_balance, funds)
-
-    @pytest.mark.anyio
-    async def test_tx_propagation(self, three_nodes_two_wallets, self_hostname, seeded_random: random.Random):
-        num_blocks = 5
-        full_nodes, wallets, _ = three_nodes_two_wallets
-
-        wallet_0, wallet_server_0 = wallets[0]
-        wallet_1, wallet_server_1 = wallets[1]
-        full_node_api_0 = full_nodes[0]
-        server_0 = full_node_api_0.server
-        full_node_api_1 = full_nodes[1]
-        server_1 = full_node_api_1.server
-        full_node_api_2 = full_nodes[2]
-        server_2 = full_node_api_2.server
-
-        ph = await wallet_0.wallet_state_manager.main_wallet.get_new_puzzlehash()
-        ph1 = await wallet_1.wallet_state_manager.main_wallet.get_new_puzzlehash()
-
-        #
-        # wallet0 <-> sever0 <-> server1 <-> server2 <-> wallet1
-        #
-        await wallet_server_0.start_client(PeerInfo(self_hostname, server_0.get_port()), None)
-        await server_0.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
-        await server_1.start_client(PeerInfo(self_hostname, server_2.get_port()), None)
-        await wallet_server_1.start_client(PeerInfo(self_hostname, server_2.get_port()), None)
-
-        for i in range(num_blocks):
-            await full_node_api_0.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-
-        funds = sum(
-            calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)
-        )
-        await time_out_assert(20, wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance, funds)
-
-        async def peak_height(fna: FullNodeAPI):
-            peak: Optional[BlockRecord] = fna.full_node.blockchain.get_peak()
-            if peak is None:
-                return -1
-            peak_height = peak.height
-            return peak_height
-
-        await time_out_assert(20, peak_height, num_blocks, full_node_api_1)
-        await time_out_assert(20, peak_height, num_blocks, full_node_api_2)
-
-        async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-            await wallet_0.wallet_state_manager.main_wallet.generate_signed_transaction(10, ph1, action_scope, 0)
-        [tx] = action_scope.side_effects.transactions
-
-        await time_out_assert(
-            10,
-            full_node_api_0.full_node.mempool_manager.get_spendbundle,
-            tx.spend_bundle,
-            tx.name,
-        )
-        await time_out_assert(
-            10,
-            full_node_api_1.full_node.mempool_manager.get_spendbundle,
-            tx.spend_bundle,
-            tx.name,
-        )
-        await time_out_assert(
-            10,
-            full_node_api_2.full_node.mempool_manager.get_spendbundle,
-            tx.spend_bundle,
-            tx.name,
-        )
-
-        # Farm another block
-        for i in range(1, 8):
-            await full_node_api_1.farm_new_transaction_block(FarmNewBlockProtocol(bytes32.random(seeded_random)))
-        funds = sum(
-            calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)
-        )
-        print(f"Funds: {funds}")
-        await time_out_assert(
-            10,
-            wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance,
-            (funds - 10),
-        )
-        await time_out_assert(20, wallet_1.wallet_state_manager.main_wallet.get_confirmed_balance, 10)
-
-    @pytest.mark.anyio
-    async def test_mempool_tx_sync(self, three_nodes_two_wallets, self_hostname, seeded_random: random.Random):
-        num_blocks = 5
-        full_nodes, wallets, _ = three_nodes_two_wallets
-
-        wallet_0, wallet_server_0 = wallets[0]
-        full_node_api_0 = full_nodes[0]
-        server_0 = full_node_api_0.server
-        full_node_api_1 = full_nodes[1]
-        server_1 = full_node_api_1.server
-        full_node_api_2 = full_nodes[2]
-        server_2 = full_node_api_2.server
-
-        ph = await wallet_0.wallet_state_manager.main_wallet.get_new_puzzlehash()
-
-        # wallet0 <-> sever0 <-> server1
-
-        await wallet_server_0.start_client(PeerInfo(self_hostname, server_0.get_port()), None)
-        await server_0.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
-
-        for i in range(num_blocks):
-            await full_node_api_0.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-
-        all_blocks = await full_node_api_0.get_all_full_blocks()
-
-        for block in all_blocks:
-            await full_node_api_2.full_node.add_block(block)
-
-        funds = sum(
-            calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)
-        )
-        await time_out_assert(20, wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance, funds)
-
-        async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-            await wallet_0.wallet_state_manager.main_wallet.generate_signed_transaction(
-                10, bytes32.random(seeded_random), action_scope, 0
-            )
-        [tx] = action_scope.side_effects.transactions
-
-        await time_out_assert(
-            10,
-            full_node_api_0.full_node.mempool_manager.get_spendbundle,
-            tx.spend_bundle,
-            tx.name,
-        )
-        await time_out_assert(
-            10,
-            full_node_api_1.full_node.mempool_manager.get_spendbundle,
-            tx.spend_bundle,
-            tx.name,
-        )
-        await time_out_assert(
-            10,
-            full_node_api_2.full_node.mempool_manager.get_spendbundle,
-            None,
-            tx.name,
-        )
-
-        # make a final connection.
-        # wallet0 <-> sever0 <-> server1 <-> server2
-
-        await server_1.start_client(PeerInfo(self_hostname, server_2.get_port()), None)
-
-        await time_out_assert(
-            10,
-            full_node_api_0.full_node.mempool_manager.get_spendbundle,
-            tx.spend_bundle,
-            tx.name,
-        )
-        await time_out_assert(
-            10,
-            full_node_api_1.full_node.mempool_manager.get_spendbundle,
-            tx.spend_bundle,
-            tx.name,
-        )
-        await time_out_assert(
-            10,
-            full_node_api_2.full_node.mempool_manager.get_spendbundle,
-            tx.spend_bundle,
-            tx.name,
+@pytest.mark.anyio
+async def test_wallet_coinbase(simulator_and_wallet, self_hostname):
+    num_blocks = 5
+    full_nodes, wallets, _ = simulator_and_wallet
+    full_node_api = full_nodes[0]
+    full_node_server = full_node_api.server
+    wallet_node, server_2 = wallets[0]
+    wallet = wallet_node.wallet_state_manager.main_wallet
+    ph = await wallet.get_new_puzzlehash()
+
+    await server_2.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
+    for i in range(num_blocks):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+
+    funds = sum(
+        calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)
+    )
+    # funds += calculate_base_farmer_reward(0)
+    await asyncio.sleep(2)
+    print(await wallet.get_confirmed_balance(), funds)
+    await time_out_assert(20, wallet.get_confirmed_balance, funds)
+
+
+@pytest.mark.anyio
+async def test_tx_propagation(three_nodes_two_wallets, self_hostname, seeded_random: random.Random):
+    num_blocks = 5
+    full_nodes, wallets, _ = three_nodes_two_wallets
+
+    wallet_0, wallet_server_0 = wallets[0]
+    wallet_1, wallet_server_1 = wallets[1]
+    full_node_api_0 = full_nodes[0]
+    server_0 = full_node_api_0.server
+    full_node_api_1 = full_nodes[1]
+    server_1 = full_node_api_1.server
+    full_node_api_2 = full_nodes[2]
+    server_2 = full_node_api_2.server
+
+    ph = await wallet_0.wallet_state_manager.main_wallet.get_new_puzzlehash()
+    ph1 = await wallet_1.wallet_state_manager.main_wallet.get_new_puzzlehash()
+
+    #
+    # wallet0 <-> sever0 <-> server1 <-> server2 <-> wallet1
+    #
+    await wallet_server_0.start_client(PeerInfo(self_hostname, server_0.get_port()), None)
+    await server_0.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+    await server_1.start_client(PeerInfo(self_hostname, server_2.get_port()), None)
+    await wallet_server_1.start_client(PeerInfo(self_hostname, server_2.get_port()), None)
+
+    for i in range(num_blocks):
+        await full_node_api_0.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+
+    funds = sum(
+        calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)
+    )
+    await time_out_assert(20, wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance, funds)
+
+    async def peak_height(fna: FullNodeAPI):
+        peak: Optional[BlockRecord] = fna.full_node.blockchain.get_peak()
+        if peak is None:
+            return -1
+        peak_height = peak.height
+        return peak_height
+
+    await time_out_assert(20, peak_height, num_blocks, full_node_api_1)
+    await time_out_assert(20, peak_height, num_blocks, full_node_api_2)
+
+    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        await wallet_0.wallet_state_manager.main_wallet.generate_signed_transaction([10], [ph1], action_scope, 0)
+    [tx] = action_scope.side_effects.transactions
+
+    await time_out_assert(
+        10,
+        full_node_api_0.full_node.mempool_manager.get_spendbundle,
+        tx.spend_bundle,
+        tx.name,
+    )
+    await time_out_assert(
+        10,
+        full_node_api_1.full_node.mempool_manager.get_spendbundle,
+        tx.spend_bundle,
+        tx.name,
+    )
+    await time_out_assert(
+        10,
+        full_node_api_2.full_node.mempool_manager.get_spendbundle,
+        tx.spend_bundle,
+        tx.name,
+    )
+
+    # Farm another block
+    for i in range(1, 8):
+        await full_node_api_1.farm_new_transaction_block(FarmNewBlockProtocol(bytes32.random(seeded_random)))
+    funds = sum(
+        calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks + 1)
+    )
+    print(f"Funds: {funds}")
+    await time_out_assert(
+        10,
+        wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance,
+        (funds - 10),
+    )
+    await time_out_assert(20, wallet_1.wallet_state_manager.main_wallet.get_confirmed_balance, 10)
+
+
+@pytest.mark.anyio
+async def test_mempool_tx_sync(three_nodes_two_wallets, self_hostname, seeded_random: random.Random):
+    num_blocks = 5
+    full_nodes, wallets, _ = three_nodes_two_wallets
+
+    wallet_0, wallet_server_0 = wallets[0]
+    full_node_api_0 = full_nodes[0]
+    server_0 = full_node_api_0.server
+    full_node_api_1 = full_nodes[1]
+    server_1 = full_node_api_1.server
+    full_node_api_2 = full_nodes[2]
+    server_2 = full_node_api_2.server
+
+    ph = await wallet_0.wallet_state_manager.main_wallet.get_new_puzzlehash()
+
+    # wallet0 <-> sever0 <-> server1
+
+    await wallet_server_0.start_client(PeerInfo(self_hostname, server_0.get_port()), None)
+    await server_0.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+
+    for i in range(num_blocks):
+        await full_node_api_0.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+
+    all_blocks = await full_node_api_0.get_all_full_blocks()
+
+    for block in all_blocks:
+        await full_node_api_2.full_node.add_block(block)
+
+    funds = sum(
+        calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)
+    )
+    await time_out_assert(20, wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance, funds)
+
+    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        await wallet_0.wallet_state_manager.main_wallet.generate_signed_transaction(
+            [10], [bytes32.random(seeded_random)], action_scope, 0
         )
+    [tx] = action_scope.side_effects.transactions
+
+    await time_out_assert(
+        10,
+        full_node_api_0.full_node.mempool_manager.get_spendbundle,
+        tx.spend_bundle,
+        tx.name,
+    )
+    await time_out_assert(
+        10,
+        full_node_api_1.full_node.mempool_manager.get_spendbundle,
+        tx.spend_bundle,
+        tx.name,
+    )
+    await time_out_assert(
+        10,
+        full_node_api_2.full_node.mempool_manager.get_spendbundle,
+        None,
+        tx.name,
+    )
+
+    # make a final connection.
+    # wallet0 <-> sever0 <-> server1 <-> server2
+
+    await server_1.start_client(PeerInfo(self_hostname, server_2.get_port()), None)
+
+    await time_out_assert(
+        10,
+        full_node_api_0.full_node.mempool_manager.get_spendbundle,
+        tx.spend_bundle,
+        tx.name,
+    )
+    await time_out_assert(
+        10,
+        full_node_api_1.full_node.mempool_manager.get_spendbundle,
+        tx.spend_bundle,
+        tx.name,
+    )
+    await time_out_assert(
+        10,
+        full_node_api_2.full_node.mempool_manager.get_spendbundle,
+        tx.spend_bundle,
+        tx.name,
+    )

chia/_tests/core/full_node/test_tx_processing_queue.py

@@ -7,9 +7,9 @@ from dataclasses import dataclass
 from typing import Optional, cast
 
 import pytest
+from chia_rs.sized_bytes import bytes32
 
 from chia.full_node.tx_processing_queue import TransactionQueue, TransactionQueueFull
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.transaction_queue_entry import TransactionQueueEntry
 from chia.util.task_referencer import create_referenced_task
 

chia/_tests/core/make_block_generator.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
 from chia_rs import G1Element, G2Element, PrivateKey
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
 
 from chia.full_node.bundle_tools import simple_solution_generator
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.generator_types import BlockGenerator
 from chia.types.spend_bundle import SpendBundle
-from chia.util.ints import uint64
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_for_pk, solution_for_conditions
 
 GROUP_ORDER = 0x73EDA753299D7D483339D80809A1D80553BDA402FFFE5BFEFFFFFFFF00000001