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

chia/_tests/core/mempool/test_mempool_performance.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import pytest
+from chia_rs.sized_ints import uint64, uint128
 
 from chia._tests.util.misc import BenchmarkRunner, wallet_height_at_least
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
@@ -9,7 +10,6 @@ from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.types.full_block import FullBlock
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.peer_info import PeerInfo
-from chia.util.ints import uint64, uint128
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.wallet_node import WalletNode
 
@@ -45,7 +45,7 @@ async def test_mempool_update_performance(
 
     ph = await wallet.get_new_puzzlehash()
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False, sign=True) as action_scope:
-        await wallet.generate_signed_transaction(send_amount, ph, action_scope, fee_amount)
+        await wallet.generate_signed_transaction([send_amount], [ph], action_scope, fee_amount)
     [big_transaction] = action_scope.side_effects.transactions
     assert big_transaction.spend_bundle is not None
     status, err = await full_node.add_transaction(

chia/_tests/core/mempool/test_singleton_fast_forward.py

@@ -6,6 +6,8 @@ from typing import Any, Optional
 
 import pytest
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
 from chiabip158 import PyBIP158
 
 from chia._tests.clvm.test_puzzles import public_key_for_index, secret_exponent_for_index
@@ -24,7 +26,6 @@ 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.blockchain_format.serialized_program import SerializedProgram
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_spend import CoinSpend, make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.eligible_coin_spends import EligibleCoinSpends, UnspentLineageInfo, perform_the_fast_forward
@@ -33,7 +34,6 @@ from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.mempool_item import BundleCoinSpend
 from chia.types.spend_bundle import SpendBundle
 from chia.util.errors import Err
-from chia.util.ints import uint64
 from chia.wallet.puzzles import p2_conditions, p2_delegated_puzzle_or_hidden_puzzle
 from chia.wallet.puzzles import singleton_top_layer_v1_1 as singleton_top_layer
 
@@ -123,9 +123,9 @@ async def test_process_fast_forward_spends_latest_unspent() -> None:
         assert False  # pragma: no cover
 
     # At this point, spends are considered *potentially* eligible for singleton
-    # fast forward mainly when their amount is even and they don't have conditions
+    # fast forward mainly when their amount is odd and they don't have conditions
     # that disqualify them
-    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, test_amount - 2]]
+    conditions = [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, test_amount]]
     sb = spend_bundle_from_conditions(conditions, test_coin)
     item = mempool_item_from_spendbundle(sb)
     assert item.bundle_coin_spends[test_coin.name()].eligible_for_fast_forward is True
@@ -416,7 +416,7 @@ async def test_singleton_fast_forward_solo() -> None:
             parent_parent_id=eve_coin_spend.coin.parent_coin_info,
         )
 
-        inner_conditions = [[ConditionOpcode.CREATE_COIN, inner_puzzle_hash, 21]]
+        inner_conditions = [[ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_AMOUNT]]
         # this is a FF spend that isn't combined with any other spend. It's not allowed
         singleton_coin_spend, _ = make_singleton_coin_spend(eve_coin_spend, singleton, inner_puzzle, inner_conditions)
         status, error = await sim_client.push_tx(SpendBundle([singleton_coin_spend], G2Element()))
@@ -437,8 +437,6 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
     START_AMOUNT = uint64(1337)
     # We're decrementing the next iteration's amount for testing purposes
     SINGLETON_AMOUNT = uint64(1335)
-    # We're incrementing the next iteration's amount for testing purposes
-    SINGLETON_CHILD_AMOUNT = uint64(1339)
     async with sim_and_client() as (sim, sim_client):
         singleton, eve_coin_spend, inner_puzzle, remaining_coin = await prepare_and_test_singleton(
             sim, sim_client, is_eligible_for_ff, START_AMOUNT, SINGLETON_AMOUNT
@@ -452,15 +450,14 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
         sig = AugSchemeMPL.sign(sk, b"foobar", g1)
         inner_conditions: list[list[Any]] = [
             [ConditionOpcode.AGG_SIG_UNSAFE, bytes(g1), b"foobar"],
-            [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_CHILD_AMOUNT],
+            [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_AMOUNT],
         ]
         singleton_coin_spend, singleton_signing_puzzle = make_singleton_coin_spend(
             eve_coin_spend, singleton, inner_puzzle, inner_conditions
         )
-        # Spend also a remaining coin for balance, as we're increasing the singleton amount
-        diff_to_balance = SINGLETON_CHILD_AMOUNT - SINGLETON_AMOUNT
+        # Spend also a remaining coin
         remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - diff_to_balance]])
+            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]])
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         await make_and_send_spend_bundle(
@@ -476,7 +473,7 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
             singleton_puzzle_hash
         )
         singleton_child, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
-        assert singleton_child.amount == SINGLETON_CHILD_AMOUNT
+        assert singleton_child.amount == SINGLETON_AMOUNT
         assert unspent_lineage_info == UnspentLineageInfo(
             coin_id=singleton_child.name(),
             coin_amount=singleton_child.amount,
@@ -486,7 +483,7 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
         )
         # Now let's spend the first version again (despite being already spent by now)
         remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - diff_to_balance]])
+            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]])
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         status, error = await make_and_send_spend_bundle(
@@ -532,8 +529,6 @@ async def test_singleton_fast_forward_same_block() -> None:
     START_AMOUNT = uint64(1337)
     # We're decrementing the next iteration's amount for testing purposes
     SINGLETON_AMOUNT = uint64(1335)
-    # We're incrementing the next iteration's amount for testing purposes
-    SINGLETON_CHILD_AMOUNT = uint64(1339)
     async with sim_and_client() as (sim, sim_client):
         singleton, eve_coin_spend, inner_puzzle, remaining_coin = await prepare_and_test_singleton(
             sim, sim_client, True, START_AMOUNT, SINGLETON_AMOUNT
@@ -546,13 +541,14 @@ async def test_singleton_fast_forward_same_block() -> None:
         sig = AugSchemeMPL.sign(sk, b"foobar", g1)
         inner_conditions: list[list[Any]] = [
             [ConditionOpcode.AGG_SIG_UNSAFE, bytes(g1), b"foobar"],
-            [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_CHILD_AMOUNT],
+            [ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_AMOUNT],
         ]
         singleton_coin_spend, _ = make_singleton_coin_spend(eve_coin_spend, singleton, inner_puzzle, inner_conditions)
-        # Spend also a remaining coin for balance, as we're increasing the singleton amount
-        diff_to_balance = SINGLETON_CHILD_AMOUNT - SINGLETON_AMOUNT
+        # Spend also a remaining coin. Change amount to create a new coin ID.
+        # The test assumes any odd amount is a singleton, so we must keep it
+        # even
         remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - diff_to_balance]])
+            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - 2]])
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         await make_and_send_spend_bundle(sim, sim_client, [remaining_coin_spend, singleton_coin_spend], aggsig=sig)
@@ -560,7 +556,7 @@ async def test_singleton_fast_forward_same_block() -> None:
             singleton_puzzle_hash
         )
         singleton_child, [remaining_coin] = await get_singleton_and_remaining_coins(sim)
-        assert singleton_child.amount == SINGLETON_CHILD_AMOUNT
+        assert singleton_child.amount == SINGLETON_AMOUNT
         assert unspent_lineage_info == UnspentLineageInfo(
             coin_id=singleton_child.name(),
             coin_amount=singleton_child.amount,
@@ -570,7 +566,6 @@ async def test_singleton_fast_forward_same_block() -> None:
         )
         # Now let's send 3 arbitrary spends of the already spent singleton in
         # one block. They should all properly fast forward
-        random_amounts = [21, 17, 11]
 
         sk = AugSchemeMPL.key_gen(b"a" * 32)
         g1 = sk.get_g1()
@@ -583,7 +578,7 @@ async def test_singleton_fast_forward_same_block() -> None:
             aggsig = G2Element()
             for _ in range(cost_factor):
                 aggsig += sig
-            inner_conditions.append([ConditionOpcode.CREATE_COIN, inner_puzzle_hash, random_amounts[i]])
+            inner_conditions.append([ConditionOpcode.CREATE_COIN, inner_puzzle_hash, SINGLETON_AMOUNT])
             singleton_coin_spend, _ = make_singleton_coin_spend(
                 eve_coin_spend, singleton, inner_puzzle, inner_conditions
             )
@@ -602,13 +597,13 @@ async def test_singleton_fast_forward_same_block() -> None:
         # The unspent coin ID should reflect the latest version
         assert unspent_lineage_info.coin_id == latest_singleton.name()
         # The latest version should have the last random amount
-        assert latest_singleton.amount == random_amounts[-1]
+        assert latest_singleton.amount == SINGLETON_AMOUNT
         # The unspent coin amount should reflect the latest version
         assert unspent_lineage_info.coin_amount == latest_singleton.amount
         # The unspent parent ID should reflect the latest version's parent
         assert unspent_lineage_info.parent_id == latest_singleton.parent_coin_info
         # The one before it should have the second last random amount
-        assert unspent_lineage_info.parent_amount == random_amounts[-2]
+        assert unspent_lineage_info.parent_amount == SINGLETON_AMOUNT
 
 
 @pytest.mark.anyio
@@ -676,7 +671,6 @@ async def test_mempool_items_immutability_on_ff() -> None:
         # Let's trigger the fast forward by creating a mempool bundle
         result = await sim.mempool_manager.create_bundle_from_mempool(
             sim_client.service.block_records[-1].header_hash,
-            sim_client.service.coin_store.get_unspent_lineage_info_for_puzzle_hash,
         )
         assert result is not None
         bundle, _ = result

chia/_tests/core/node_height.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from chia_rs.sized_ints import uint32
+
 from chia.full_node.full_node_api import FullNodeAPI
-from chia.util.ints import uint32
 
 
 def node_height_at_least(node: FullNodeAPI, h: uint32) -> bool:

chia/_tests/core/server/test_capabilities.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import pytest
+from chia_rs.sized_ints import uint16
 
 from chia.protocols.shared_protocol import Capability
 from chia.server.capabilities import known_active_capabilities
-from chia.util.ints import uint16
 
 
 @pytest.mark.parametrize(

chia/_tests/core/server/test_dos.py

@@ -7,13 +7,14 @@ from typing import Optional
 
 import pytest
 from aiohttp import ClientSession, ClientTimeout, WSCloseCode, WSMessage, WSMsgType, WSServerHandshakeError
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint16, uint64
 
 import chia.server.server
 from chia._tests.util.time_out_assert import time_out_assert
-from chia.full_node.full_node_api import FullNodeAPI
 from chia.protocols import full_node_protocol
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.protocols.shared_protocol import Handshake
+from chia.protocols.shared_protocol import Capability, Handshake
 from chia.server.outbound_message import Message, make_msg
 from chia.server.rate_limits import RateLimiter
 from chia.server.server import ChiaServer
@@ -22,7 +23,6 @@ from chia.simulator.block_tools import BlockTools
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.types.peer_info import PeerInfo
 from chia.util.errors import Err
-from chia.util.ints import uint64
 from chia.util.timing import adjusted_timeout
 from chia.wallet.wallet_node import WalletNode
 
@@ -33,18 +33,10 @@ def not_localhost(host: str) -> bool:
     return False
 
 
-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 FakeRateLimiter:
-    def process_msg_and_check(self, msg, capa, capb) -> Optional[str]:
+    def process_msg_and_check(
+        self, message: Message, our_capabilities: list[Capability], peer_capabilities: list[Capability]
+    ) -> Optional[str]:
         return None
 
 
@@ -142,7 +134,11 @@ class TestDos:
         await ws.close()
 
     @pytest.mark.anyio
-    async def test_invalid_protocol_handshake(self, setup_two_nodes_fixture, self_hostname):
+    async def test_invalid_protocol_handshake(
+        self,
+        setup_two_nodes_fixture: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
+        self_hostname: str,
+    ) -> None:
         nodes, _, _ = setup_two_nodes_fixture
         server_1 = nodes[0].full_node.server
         server_2 = nodes[1].full_node.server
@@ -159,8 +155,8 @@ class TestDos:
         )
 
         # Construct an otherwise valid handshake message
-        handshake: Handshake = Handshake("test", "0.0.32", "1.0.0.0", 3456, 1, [(1, "1")])
-        outbound_handshake: Message = Message(2, None, bytes(handshake))  # 2 is an invalid ProtocolType
+        handshake: Handshake = Handshake("test", "0.0.32", "1.0.0.0", uint16(3456), uint8(1), [(uint16(1), "1")])
+        outbound_handshake: Message = Message(uint8(2), None, bytes(handshake))  # 2 is an invalid ProtocolType
         await ws.send_bytes(bytes(outbound_handshake))
 
         response: WSMessage = await ws.receive()
@@ -173,7 +169,11 @@ class TestDos:
         await asyncio.sleep(1)  # give some time for cleanup to work
 
     @pytest.mark.anyio
-    async def test_spam_tx(self, setup_two_nodes_fixture, self_hostname):
+    async def test_spam_tx(
+        self,
+        setup_two_nodes_fixture: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
+        self_hostname: str,
+    ) -> None:
         nodes, _, _ = setup_two_nodes_fixture
         _full_node_1, full_node_2 = nodes
         server_1 = nodes[0].full_node.server
@@ -191,7 +191,7 @@ class TestDos:
 
         new_tx_message = make_msg(
             ProtocolMessageTypes.new_transaction,
-            full_node_protocol.NewTransaction(bytes([9] * 32), uint64(0), uint64(0)),
+            full_node_protocol.NewTransaction(bytes32([9] * 32), uint64(0), uint64(0)),
         )
         for i in range(4000):
             await ws_con._send_message(new_tx_message)
@@ -215,20 +215,24 @@ class TestDos:
                 await asyncio.sleep(0)
         await asyncio.sleep(1)
 
-        def is_closed():
+        def is_closed() -> bool:
             return ws_con.closed
 
         await time_out_assert(15, is_closed)
 
         assert ws_con.closed
 
-        def is_banned():
+        def is_banned() -> bool:
             return "1.2.3.4" in server_2.banned_peers
 
         await time_out_assert(15, is_banned)
 
     @pytest.mark.anyio
-    async def test_spam_message_non_tx(self, setup_two_nodes_fixture, self_hostname):
+    async def test_spam_message_non_tx(
+        self,
+        setup_two_nodes_fixture: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
+        self_hostname: str,
+    ) -> None:
         nodes, _, _ = setup_two_nodes_fixture
         _full_node_1, full_node_2 = nodes
         server_1 = nodes[0].full_node.server
@@ -244,7 +248,7 @@ class TestDos:
         ws_con.peer_info = PeerInfo("1.2.3.4", ws_con.peer_info.port)
         ws_con_2.peer_info = PeerInfo("1.2.3.4", ws_con_2.peer_info.port)
 
-        def is_closed():
+        def is_closed() -> bool:
             return ws_con.closed
 
         new_message = make_msg(
@@ -271,13 +275,17 @@ class TestDos:
         await time_out_assert(15, is_closed)
 
         # Banned
-        def is_banned():
+        def is_banned() -> bool:
             return "1.2.3.4" in server_2.banned_peers
 
         await time_out_assert(15, is_banned)
 
     @pytest.mark.anyio
-    async def test_spam_message_too_large(self, setup_two_nodes_fixture, self_hostname):
+    async def test_spam_message_too_large(
+        self,
+        setup_two_nodes_fixture: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
+        self_hostname: str,
+    ) -> None:
         nodes, _, _ = setup_two_nodes_fixture
         _full_node_1, full_node_2 = nodes
         server_1 = nodes[0].full_node.server
@@ -293,7 +301,7 @@ class TestDos:
         ws_con.peer_info = PeerInfo("1.2.3.4", ws_con.peer_info.port)
         ws_con_2.peer_info = PeerInfo("1.2.3.4", ws_con_2.peer_info.port)
 
-        def is_closed():
+        def is_closed() -> bool:
             return ws_con.closed
 
         new_message = make_msg(
@@ -307,13 +315,13 @@ class TestDos:
         assert not ws_con.closed
 
         # Remove outbound rate limiter to test inbound limits
-        ws_con.outbound_rate_limiter = FakeRateLimiter()
+        ws_con.outbound_rate_limiter = FakeRateLimiter()  # type: ignore[assignment]
 
         await ws_con._send_message(new_message)
         await time_out_assert(15, is_closed)
 
         # Banned
-        def is_banned():
+        def is_banned() -> bool:
             return "1.2.3.4" in server_2.banned_peers
 
         await time_out_assert(15, is_banned)

chia/_tests/core/server/test_loop.py

@@ -245,9 +245,9 @@ async def test_loop(tmp_path: pathlib.Path) -> None:
     assert "Traceback" not in serve_output
     assert "paused accepting connections" in serve_output
     assert post_connection_succeeded, post_connection_error
-    assert all(
-        "new connection" not in line.casefold() for line in shutdown_lines
-    ), "new connection found during shut down"
+    assert all("new connection" not in line.casefold() for line in shutdown_lines), (
+        "new connection found during shut down"
+    )
 
     logger.info(" ==== all checks passed")
 

chia/_tests/core/server/test_rate_limits.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 
 import pytest
+from chia_rs.sized_ints import uint32
 
 from chia._tests.conftest import node_with_params
 from chia._tests.util.time_out_assert import time_out_assert
@@ -17,7 +18,6 @@ from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.block_tools import BlockTools
 from chia.types.peer_info import PeerInfo
-from chia.util.ints import uint32
 
 rl_v2 = [Capability.BASE, Capability.BLOCK_HEADERS, Capability.RATE_LIMITS_V2]
 rl_v1 = [Capability.BASE]

chia/_tests/core/server/test_server.py

@@ -5,6 +5,8 @@ from dataclasses import dataclass
 from typing import Callable, ClassVar, cast
 
 import pytest
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import int16, uint32
 from packaging.version import Version
 
 from chia import __version__
@@ -23,10 +25,8 @@ from chia.server.start_full_node import create_full_node_service
 from chia.server.start_wallet import create_wallet_service
 from chia.server.ws_connection import WSChiaConnection, error_response_version
 from chia.simulator.block_tools import BlockTools
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.peer_info import PeerInfo
 from chia.util.errors import ApiError, Err
-from chia.util.ints import int16, uint32
 
 
 @dataclass

chia/_tests/core/services/test_services.py

@@ -11,6 +11,7 @@ from typing import Any, Optional, cast
 
 import aiohttp.client_exceptions
 import pytest
+from chia_rs.sized_ints import uint16
 from typing_extensions import Protocol
 
 from chia._tests.core.data_layer.util import ChiaRoot
@@ -24,7 +25,6 @@ from chia.rpc.rpc_client import RpcClient
 from chia.rpc.wallet_rpc_client import WalletRpcClient
 from chia.simulator.socket import find_available_listen_port
 from chia.util.config import lock_and_load_config, save_config
-from chia.util.ints import uint16
 from chia.util.timing import adjusted_timeout
 
 if sys.platform == "win32" or sys.platform == "cygwin":

chia/_tests/core/ssl/test_ssl.py

@@ -7,6 +7,7 @@ import ssl
 
 import aiohttp
 import pytest
+from chia_rs.sized_bytes import bytes32
 
 from chia.apis import ApiProtocolRegistry
 from chia.protocols.shared_protocol import default_capabilities
@@ -15,7 +16,6 @@ from chia.server.server import ChiaServer, ssl_context_for_client
 from chia.server.ssl_context import chia_ssl_ca_paths, private_ssl_ca_paths
 from chia.server.ws_connection import WSChiaConnection
 from chia.ssl.create_ssl import generate_ca_signed_cert
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.peer_info import PeerInfo
 
 

chia/_tests/core/test_coins.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 from itertools import permutations
 
+from chia_rs.sized_bytes import bytes32
+
 from chia._tests.util.benchmarks import rand_hash
 from chia.types.blockchain_format.coin import hash_coin_ids
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.hash import std_hash
 
 

chia/_tests/core/test_cost_calculation.py

@@ -5,6 +5,8 @@ import pathlib
 
 import pytest
 from chia_rs import G1Element
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 from clvm_tools import binutils
 
 from chia._tests.core.make_block_generator import make_block_generator
@@ -19,9 +21,7 @@ from chia.simulator.block_tools import BlockTools, test_constants
 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.generator_types import BlockGenerator
-from chia.util.ints import uint32, uint64
 from chia.wallet.puzzles import p2_delegated_puzzle_or_hidden_puzzle
 
 BURN_PUZZLE_HASH = bytes32(b"0" * 32)

chia/_tests/core/test_crawler.py

@@ -6,6 +6,8 @@ from datetime import datetime, timedelta
 from typing import cast
 
 import pytest
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64, uint128
 
 from chia._tests.util.setup_nodes import SimulatorsAndWalletsServices
 from chia._tests.util.time_out_assert import time_out_assert
@@ -16,9 +18,7 @@ from chia.protocols.wallet_protocol import RequestChildren
 from chia.seeder.peer_record import PeerRecord, PeerReliability
 from chia.server.outbound_message import make_msg
 from chia.types.aliases import CrawlerService
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.peer_info import PeerInfo
-from chia.util.ints import uint32, uint64, uint128
 
 
 @pytest.mark.anyio

chia/_tests/core/test_db_conversion.py

@@ -4,6 +4,8 @@ import random
 from pathlib import Path
 
 import pytest
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.util.temp_file import TempFile
 from chia.cmds.db_upgrade_func import convert_v1_to_v2
@@ -14,9 +16,7 @@ from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.hint_store import HintStore
 from chia.simulator.block_tools import test_constants
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.db_wrapper import DBWrapper2
-from chia.util.ints import uint32, uint64
 
 
 def rand_bytes(num) -> bytes:

chia/_tests/core/test_db_validation.py

@@ -4,8 +4,11 @@ import random
 import sqlite3
 from contextlib import closing
 from pathlib import Path
+from typing import Any
 
 import pytest
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.util.temp_file import TempFile
 from chia.cmds.db_validate_func import validate_v2
@@ -16,10 +19,8 @@ from chia.consensus.multiprocess_validation import PreValidationResult
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.simulator.block_tools import test_constants
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.full_block import FullBlock
 from chia.util.db_wrapper import DBWrapper2
-from chia.util.ints import uint32, uint64
 
 
 def rand_hash() -> bytes32:
@@ -69,27 +70,32 @@ def add_block(
     )
 
 
-def test_db_validate_wrong_version() -> None:
+@pytest.fixture(name="default_config")
+def default_config_fixture() -> dict[str, Any]:
+    return {"full_node": {"selected_network": "local", "network_overrides": {"constants": {"local": {}}}}}
+
+
+def test_db_validate_wrong_version(default_config: dict[str, Any]) -> None:
     with TempFile() as db_file:
         with closing(sqlite3.connect(db_file)) as conn:
             make_version(conn, 3)
 
         with pytest.raises(RuntimeError) as execinfo:
-            validate_v2(db_file, validate_blocks=False)
+            validate_v2(db_file, config=default_config, validate_blocks=False)
         assert "Database has the wrong version (3 expected 2)" in str(execinfo.value)
 
 
-def test_db_validate_missing_peak_table() -> None:
+def test_db_validate_missing_peak_table(default_config: dict[str, Any]) -> None:
     with TempFile() as db_file:
         with closing(sqlite3.connect(db_file)) as conn:
             make_version(conn, 2)
 
         with pytest.raises(RuntimeError) as execinfo:
-            validate_v2(db_file, validate_blocks=False)
+            validate_v2(db_file, config=default_config, validate_blocks=False)
         assert "Database is missing current_peak table" in str(execinfo.value)
 
 
-def test_db_validate_missing_peak_block() -> None:
+def test_db_validate_missing_peak_block(default_config: dict[str, Any]) -> None:
     with TempFile() as db_file:
         with closing(sqlite3.connect(db_file)) as conn:
             make_version(conn, 2)
@@ -98,12 +104,12 @@ def test_db_validate_missing_peak_block() -> None:
             make_block_table(conn)
 
         with pytest.raises(RuntimeError) as execinfo:
-            validate_v2(db_file, validate_blocks=False)
+            validate_v2(db_file, config=default_config, validate_blocks=False)
         assert "Database is missing the peak block" in str(execinfo.value)
 
 
 @pytest.mark.parametrize("invalid_in_chain", [True, False])
-def test_db_validate_in_main_chain(invalid_in_chain: bool) -> None:
+def test_db_validate_in_main_chain(invalid_in_chain: bool, default_config: dict[str, Any]) -> None:
     with TempFile() as db_file:
         with closing(sqlite3.connect(db_file)) as conn:
             make_version(conn, 2)
@@ -122,10 +128,10 @@ def test_db_validate_in_main_chain(invalid_in_chain: bool) -> None:
 
         if invalid_in_chain:
             with pytest.raises(RuntimeError) as execinfo:
-                validate_v2(db_file, validate_blocks=False)
+                validate_v2(db_file, config=default_config, validate_blocks=False)
             assert " (height: 96) is orphaned, but in_main_chain is set" in str(execinfo.value)
         else:
-            validate_v2(db_file, validate_blocks=False)
+            validate_v2(db_file, config=default_config, validate_blocks=False)
 
 
 async def make_db(db_file: Path, blocks: list[FullBlock]) -> None:
@@ -151,12 +157,19 @@ async def make_db(db_file: Path, blocks: list[FullBlock]) -> None:
 
 
 @pytest.mark.anyio
-async def test_db_validate_default_1000_blocks(default_1000_blocks: list[FullBlock]) -> None:
+async def test_db_validate_default_1000_blocks(
+    default_1000_blocks: list[FullBlock], default_config: dict[str, Any]
+) -> None:
     with TempFile() as db_file:
         await make_db(db_file, default_1000_blocks)
 
         # we expect everything to be valid except this is a test chain, so it
         # doesn't have the correct genesis challenge
         with pytest.raises(RuntimeError) as execinfo:
-            validate_v2(db_file, validate_blocks=True)
+            validate_v2(db_file, config=default_config, validate_blocks=True)
         assert "Blockchain has invalid genesis challenge" in str(execinfo.value)
+
+        default_config["full_node"]["network_overrides"]["constants"]["local"]["AGG_SIG_ME_ADDITIONAL_DATA"] = (
+            default_1000_blocks[0].foliage.prev_block_hash.hex()
+        )
+        validate_v2(db_file, config=default_config, validate_blocks=True)