chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5rc1__py3-none-any.whl

chia/_tests/core/custom_types/test_proof_of_space.py

@@ -5,13 +5,18 @@ from dataclasses import dataclass
 from typing import Optional
 
 import pytest
-from chia_rs import G1Element
+from chia_rs import G1Element, PlotSize, ProofOfSpace
 from chia_rs.sized_bytes import bytes32, bytes48
 from chia_rs.sized_ints import uint8, uint32
 
 from chia._tests.util.misc import Marks, datacases
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.types.blockchain_format.proof_of_space import ProofOfSpace, passes_plot_filter, verify_and_get_quality_string
+from chia.types.blockchain_format.proof_of_space import (
+    calculate_plot_difficulty,
+    calculate_prefix_bits,
+    passes_plot_filter,
+    verify_and_get_quality_string,
+)
 
 
 @dataclass
@@ -27,6 +32,15 @@ class ProofOfSpaceCase:
     marks: Marks = ()
 
 
+def g1(key: str) -> G1Element:
+    return G1Element.from_bytes_unchecked(bytes48.from_hexstr(key))
+
+
+def b32(key: str) -> bytes32:
+    return bytes32.from_hexstr(key)
+
+
+# TODO: todo_v2_plots more test cases
 @datacases(
     ProofOfSpaceCase(
         id="Neither pool public key nor pool contract puzzle hash",
@@ -70,37 +84,57 @@ class ProofOfSpaceCase:
     ),
     ProofOfSpaceCase(
         id="Not passing the plot filter with size 9",
-        pos_challenge=bytes32.from_hexstr("08b23cc2844dfb92d2eedaa705a1ce665d571ee753bd81cbb67b92caa6d34722"),
+        pos_challenge=b32("08b23cc2844dfb92d2eedaa705a1ce665d571ee753bd81cbb67b92caa6d34722"),
         plot_size=uint8(42),
-        pool_public_key=G1Element.from_bytes_unchecked(
-            bytes48.from_hexstr(
-                "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
-            )
+        pool_public_key=g1(
+            "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
         ),
-        plot_public_key=G1Element.from_bytes_unchecked(
-            bytes48.from_hexstr(
-                "b17d368f5400230b2b01464807825bf4163c5c159bd7d4465f935912e538ac9fb996dd9a9c479bd8aa6256bdca1fed96"
-            )
+        plot_public_key=g1(
+            "b17d368f5400230b2b01464807825bf4163c5c159bd7d4465f935912e538ac9fb996dd9a9c479bd8aa6256bdca1fed96"
         ),
         height=uint32(5495999),
         expected_error="Did not pass the plot filter",
     ),
     ProofOfSpaceCase(
         id="Passing the plot filter with size 8",
-        pos_challenge=bytes32.from_hexstr("08b23cc2844dfb92d2eedaa705a1ce665d571ee753bd81cbb67b92caa6d34722"),
+        pos_challenge=b32("08b23cc2844dfb92d2eedaa705a1ce665d571ee753bd81cbb67b92caa6d34722"),
         plot_size=uint8(42),
-        pool_public_key=G1Element.from_bytes_unchecked(
-            bytes48.from_hexstr(
-                "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
-            )
+        pool_public_key=g1(
+            "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
         ),
-        plot_public_key=G1Element.from_bytes_unchecked(
-            bytes48.from_hexstr(
-                "b17d368f5400230b2b01464807825bf4163c5c159bd7d4465f935912e538ac9fb996dd9a9c479bd8aa6256bdca1fed96"
-            )
+        plot_public_key=g1(
+            "b17d368f5400230b2b01464807825bf4163c5c159bd7d4465f935912e538ac9fb996dd9a9c479bd8aa6256bdca1fed96"
         ),
         height=uint32(5496000),
     ),
+    ProofOfSpaceCase(
+        id="v2 plot size 0",
+        pos_challenge=bytes32(b"1" * 32),
+        plot_size=uint8(0x80),
+        plot_public_key=G1Element(),
+        pool_public_key=G1Element(),
+        expected_error="Plot size is lower than the minimum",
+    ),
+    ProofOfSpaceCase(
+        id="v2 plot size 34",
+        pos_challenge=bytes32(b"1" * 32),
+        plot_size=uint8(0x80 | 34),
+        plot_public_key=G1Element(),
+        pool_public_key=G1Element(),
+        expected_error="Plot size is higher than the maximum",
+    ),
+    ProofOfSpaceCase(
+        id="Not passing the plot filter v2",
+        pos_challenge=b32("3d29ea79d19b3f7e99ebf764ae53697cbe143603909873946af6ab1ece606861"),
+        plot_size=uint8(0x80 | 32),
+        pool_public_key=g1(
+            "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
+        ),
+        plot_public_key=g1(
+            "879526b4e7b616cfd64984d8ad140d0798b048392a6f11e2faf09054ef467ea44dc0dab5e5edb2afdfa850c5c8b629cc"
+        ),
+        expected_error="Did not pass the plot filter",
+    ),
 )
 def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: ProofOfSpaceCase) -> None:
     pos = ProofOfSpace(
@@ -108,24 +142,87 @@ def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: P
         pool_public_key=case.pool_public_key,
         pool_contract_puzzle_hash=case.pool_contract_puzzle_hash,
         plot_public_key=case.plot_public_key,
-        size=case.plot_size,
+        version_and_size=case.plot_size,
         proof=b"1",
     )
     quality_string = verify_and_get_quality_string(
         pos=pos,
         constants=DEFAULT_CONSTANTS,
-        original_challenge_hash=bytes32.from_hexstr(
-            "0x73490e166d0b88347c37d921660b216c27316aae9a3450933d3ff3b854e5831a"
-        ),
-        signage_point=bytes32.from_hexstr("0x7b3e23dbd438f9aceefa9827e2c5538898189987f49b06eceb7a43067e77b531"),
+        original_challenge_hash=b32("0x73490e166d0b88347c37d921660b216c27316aae9a3450933d3ff3b854e5831a"),
+        signage_point=b32("0x7b3e23dbd438f9aceefa9827e2c5538898189987f49b06eceb7a43067e77b531"),
         height=case.height,
     )
     assert quality_string is None
     assert len(caplog.text) == 0 if case.expected_error is None else case.expected_error in caplog.text
 
 
+@datacases(
+    ProofOfSpaceCase(
+        id="v2 plot are not implemented",
+        plot_size=uint8(0x80 | 30),
+        pos_challenge=b32("47deb938e145d25d7b3b3c85ca9e3972b76c01aeeb78a02fe5d3b040d282317e"),
+        plot_public_key=g1(
+            "afa3aaf09c03885154be49216ee7fb2e4581b9c4a4d7e9cc402e27280bf0cfdbdf1b9ba674e301fd1d1450234b3b1868"
+        ),
+        pool_public_key=g1(
+            "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
+        ),
+        expected_error="NotImplementedError",
+    ),
+)
+def test_verify_and_get_quality_string_v2(caplog: pytest.LogCaptureFixture, case: ProofOfSpaceCase) -> None:
+    pos = ProofOfSpace(
+        challenge=case.pos_challenge,
+        pool_public_key=case.pool_public_key,
+        pool_contract_puzzle_hash=case.pool_contract_puzzle_hash,
+        plot_public_key=case.plot_public_key,
+        version_and_size=case.plot_size,
+        proof=b"1",
+    )
+    size = pos.size()
+    assert size.size_v2 is not None
+    assert size.size_v1 is None
+    try:
+        quality_string = verify_and_get_quality_string(
+            pos=pos,
+            constants=DEFAULT_CONSTANTS,
+            original_challenge_hash=b32("0x73490e166d0b88347c37d921660b216c27316aae9a3450933d3ff3b854e5831a"),
+            signage_point=b32("0x7b3e23dbd438f9aceefa9827e2c5538898189987f49b06eceb7a43067e77b531"),
+            height=case.height,
+        )
+    except NotImplementedError as e:
+        assert case.expected_error is not None
+        assert case.expected_error in repr(e)
+    else:
+        assert quality_string is None
+        assert len(caplog.text) == 0 if case.expected_error is None else case.expected_error in caplog.text
+
+
+@pytest.mark.parametrize(
+    "height, difficulty",
+    [
+        (0, 2),
+        (DEFAULT_CONSTANTS.HARD_FORK_HEIGHT, 2),
+        (DEFAULT_CONSTANTS.HARD_FORK2_HEIGHT, 2),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_4_HEIGHT - 1, 2),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_4_HEIGHT, 4),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_5_HEIGHT - 1, 4),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_5_HEIGHT, 5),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_6_HEIGHT - 1, 5),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_6_HEIGHT, 6),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_7_HEIGHT - 1, 6),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_7_HEIGHT, 7),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_8_HEIGHT - 1, 7),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_8_HEIGHT, 8),
+        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_8_HEIGHT + 1000000, 8),
+    ],
+)
+def test_calculate_plot_difficulty(height: uint32, difficulty: uint8) -> None:
+    assert calculate_plot_difficulty(DEFAULT_CONSTANTS, height) == difficulty
+
+
 class TestProofOfSpace:
-    @pytest.mark.parametrize("prefix_bits", [DEFAULT_CONSTANTS.NUMBER_ZERO_BITS_PLOT_FILTER, 8, 7, 6, 5, 1, 0])
+    @pytest.mark.parametrize("prefix_bits", [DEFAULT_CONSTANTS.NUMBER_ZERO_BITS_PLOT_FILTER_V1, 8, 7, 6, 5, 1, 0])
     def test_can_create_proof(self, prefix_bits: int, seeded_random: random.Random) -> None:
         """
         Tests that the change of getting a correct proof is exactly 1/target_filter.
@@ -142,3 +239,34 @@ class TestProofOfSpace:
                 success_count += 1
 
         assert abs((success_count * target_filter / num_trials) - 1) < 0.35
+
+
+@pytest.mark.parametrize("height,expected", [(0, 3), (5496000, 2), (10542000, 1), (15592000, 0), (20643000, 0)])
+@pytest.mark.parametrize("plot_size", [PlotSize.make_v1(32), PlotSize.make_v2(28)])
+def test_calculate_prefix_bits_clamp_zero(height: uint32, expected: int, plot_size: PlotSize) -> None:
+    constants = DEFAULT_CONSTANTS.replace(NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(3))
+    if plot_size.size_v2 is not None:
+        expected = constants.NUMBER_ZERO_BITS_PLOT_FILTER_V2
+    assert calculate_prefix_bits(constants, height, plot_size) == expected
+
+
+@pytest.mark.parametrize(
+    argnames=["height", "expected"],
+    argvalues=[
+        (0, 9),
+        (5495999, 9),
+        (5496000, 8),
+        (10541999, 8),
+        (10542000, 7),
+        (15591999, 7),
+        (15592000, 6),
+        (20642999, 6),
+        (20643000, 5),
+    ],
+)
+@pytest.mark.parametrize("plot_size", [PlotSize.make_v1(32), PlotSize.make_v2(28)])
+def test_calculate_prefix_bits_default(height: uint32, expected: int, plot_size: PlotSize) -> None:
+    constants = DEFAULT_CONSTANTS
+    if plot_size.size_v2 is not None:
+        expected = DEFAULT_CONSTANTS.NUMBER_ZERO_BITS_PLOT_FILTER_V2
+    assert calculate_prefix_bits(constants, height, plot_size) == expected

chia/_tests/core/custom_types/test_spend_bundle.py

@@ -4,15 +4,14 @@ import random
 import unittest
 
 import pytest
-from chia_rs import G2Element
+from chia_rs import CoinSpend, G2Element, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
-from chia.types.spend_bundle import SpendBundle
 
 BLANK_SPEND_BUNDLE = SpendBundle(coin_spends=[], aggregated_signature=G2Element())
 NULL_SIGNATURE = "0xc" + "0" * 191

chia/_tests/core/daemon/test_daemon.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import importlib.metadata
 import json
+import logging
 from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any, Optional, Union, cast
@@ -2126,3 +2127,82 @@ def test_run_plotter_bladebit(
     assert mock_run_plotter.call_args.args[1] == "bladebit"
     assert mock_run_plotter.call_args.args[2][1:] == case.expected_raw_command_args()
     mock_run_plotter.assert_called_once()
+
+
+@pytest.mark.anyio
+async def test_message_logging_redaction(
+    daemon_connection_and_temp_keychain: tuple[aiohttp.ClientWebSocketResponse, Keychain],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    ws, _ = daemon_connection_and_temp_keychain
+
+    with caplog.at_level(logging.DEBUG, logger="chia.daemon.server"):
+        sensitive_payload = create_payload(
+            "test_command",
+            {
+                "password": "secret_password",
+                "private_key": "sensitive_key_data",
+                "secret_value": "very_secret",
+                "mnemonic": "test_mnemonic_phrase",
+                "normal_field": "normal_value",
+                "nested_object": {
+                    "passphrase": "nested_secret",
+                    "api_key": "nested_api_key",
+                    "seed_mnemonic": "nested_mnemonic",
+                    "safe_field": "safe_value",
+                },
+            },
+            "test",
+            "daemon",
+        )
+
+        original_message = json.loads(sensitive_payload)
+        request_id = original_message["request_id"]
+
+        await ws.send_str(sensitive_payload)
+        await ws.receive()
+
+        log_message = next(record for record in caplog.records if "Received message:" in record.message).message
+        _, _, ws_message_str = log_message.partition("Received message: ")
+
+        # Build the expected redacted structure and sort keys like dict_to_json_str does
+        expected_redacted_data = {
+            "ack": False,
+            "command": "test_command",
+            "data": {
+                "mnemonic": "***<redacted>***",
+                "nested_object": {
+                    "api_key": "***<redacted>***",
+                    "passphrase": "***<redacted>***",
+                    "safe_field": "safe_value",
+                    "seed_mnemonic": "***<redacted>***",
+                },
+                "normal_field": "normal_value",
+                "password": "***<redacted>***",
+                "private_key": "***<redacted>***",
+                "secret_value": "***<redacted>***",
+            },
+            "destination": "daemon",
+            "origin": "test",
+            "request_id": request_id,
+        }
+
+        expected_ws_message = f"WSMessage(type=<WSMsgType.TEXT: 1>, data={expected_redacted_data!r}, extra='')"
+
+        assert ws_message_str == expected_ws_message
+
+
+@pytest.mark.anyio
+async def test_non_text_message_logging(
+    daemon_connection_and_temp_keychain: tuple[aiohttp.ClientWebSocketResponse, Keychain],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    ws, _ = daemon_connection_and_temp_keychain
+
+    with caplog.at_level(logging.DEBUG, logger="chia.daemon.server"):
+        # Close the websocket to trigger non-text message handling
+        await ws.close()
+
+        non_text_logs = [record for record in caplog.records if "Received non-text message" in record.message]
+
+        assert len(non_text_logs) == 1, "Expected one 'Received non-text message' log entry"

chia/_tests/core/data_layer/test_data_layer.py

@@ -9,7 +9,7 @@ from chia_rs.sized_bytes import bytes32
 from chia._tests.util.misc import RecordingWebServer
 from chia.data_layer.data_layer import DataLayer
 from chia.data_layer.data_layer_util import PluginRemote
-from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 
 
 async def create_sufficient_wallet_rpc_client() -> WalletRpcClient:

chia/_tests/core/data_layer/test_data_layer_util.py

@@ -10,6 +10,7 @@ from _pytest.fixtures import SubRequest
 from chia_rs.sized_bytes import bytes32
 
 from chia._tests.util.misc import Marks, datacases, measure_runtime
+from chia.data_layer.data_layer_rpc_util import MarshallableProtocol
 from chia.data_layer.data_layer_util import (
     ClearPendingRootsRequest,
     ClearPendingRootsResponse,
@@ -22,7 +23,6 @@ from chia.data_layer.data_layer_util import (
     key_hash,
     leaf_hash,
 )
-from chia.rpc.data_layer_rpc_util import MarshallableProtocol
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 

chia/_tests/core/data_layer/test_data_rpc.py

@@ -42,6 +42,8 @@ from chia.cmds.data_funcs import (
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.data_layer.data_layer import DataLayer
 from chia.data_layer.data_layer_errors import KeyNotFoundError, OfferIntegrityError
+from chia.data_layer.data_layer_rpc_api import DataLayerRpcApi
+from chia.data_layer.data_layer_rpc_client import DataLayerRpcClient
 from chia.data_layer.data_layer_util import (
     HashOnlyProof,
     OfferStore,
@@ -54,14 +56,11 @@ from chia.data_layer.data_layer_util import (
 from chia.data_layer.data_layer_wallet import DataLayerWallet, verify_offer
 from chia.data_layer.data_store import DataStore
 from chia.data_layer.download_data import get_delta_filename_path, get_full_tree_filename_path
-from chia.rpc.data_layer_rpc_api import DataLayerRpcApi
-from chia.rpc.data_layer_rpc_client import DataLayerRpcClient
-from chia.rpc.wallet_rpc_api import WalletRpcApi
+from chia.server.aliases import DataLayerService, WalletService
 from chia.server.start_data_layer import create_data_layer_service
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
-from chia.types.aliases import DataLayerService, WalletService
 from chia.types.peer_info import PeerInfo
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.config import save_config
@@ -71,8 +70,11 @@ from chia.util.task_referencer import create_referenced_task
 from chia.util.timing import adjusted_timeout, backoff_times
 from chia.wallet.trading.offer import Offer as TradingOffer
 from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_node import WalletNode
+from chia.wallet.wallet_request_types import DLLatestSingleton
+from chia.wallet.wallet_rpc_api import WalletRpcApi
 
 pytestmark = pytest.mark.data_layer
 nodes = tuple[WalletNode, FullNodeSimulator]
@@ -160,7 +162,8 @@ async def init_wallet_and_node(
     wallet_node = wallet_service._node
     full_node_api = full_node_service._api
     await wallet_node.server.start_client(PeerInfo(self_hostname, full_node_api.server.get_port()), None)
-    ph = await wallet_node.wallet_state_manager.main_wallet.get_new_puzzlehash()
+    async with wallet_node.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet_node.wallet_state_manager)
     await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
     await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
     funds = calculate_pool_reward(uint32(1)) + calculate_base_farmer_reward(uint32(1))
@@ -213,7 +216,7 @@ async def check_coin_state(wallet_node: WalletNode, coin_id: bytes32) -> bool:
 
 
 async def check_singleton_confirmed(dl: DataLayer, store_id: bytes32) -> bool:
-    return await dl.wallet_rpc.dl_latest_singleton(store_id, True) is not None
+    return (await dl.wallet_rpc.dl_latest_singleton(DLLatestSingleton(store_id, True))).singleton is not None
 
 
 async def process_block_and_check_offer_validity(offer: TradingOffer, offer_setup: OfferSetup) -> bool:
@@ -730,8 +733,9 @@ async def test_get_owned_stores(
     wallet_rpc_port = wallet_service.rpc_server.listen_port
     full_node_api = full_node_service._api
     await wallet_node.server.start_client(PeerInfo(self_hostname, full_node_api.server.get_port()), None)
-    ph = await wallet_node.wallet_state_manager.main_wallet.get_new_puzzlehash()
-    for i in range(0, num_blocks):
+    async with wallet_node.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet_node.wallet_state_manager)
+    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)
@@ -749,7 +753,7 @@ async def test_get_owned_stores(
             expected_store_ids.append(launcher_id)
 
         await time_out_assert(4, check_mempool_spend_count, True, full_node_api, 3)
-        for i in range(0, num_blocks):
+        for i in range(num_blocks):
             await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
             await asyncio.sleep(0.5)
 
@@ -3785,7 +3789,7 @@ async def test_auto_subscribe_to_local_stores(
 
     with monkeypatch.context() as m:
         m.setattr("chia.data_layer.data_store.DataStore.get_store_ids", mock_get_store_ids)
-        m.setattr("chia.rpc.wallet_rpc_client.WalletRpcClient.dl_track_new", mock_dl_track_new)
+        m.setattr("chia.wallet.wallet_rpc_client.WalletRpcClient.dl_track_new", mock_dl_track_new)
 
         config = bt.config
         config["data_layer"]["auto_subscribe_to_local_stores"] = auto_subscribe_to_local_stores

chia/_tests/core/data_layer/test_data_store.py

@@ -107,7 +107,7 @@ async def test_create_tree_accepts_bytes32(raw_data_store: DataStore) -> None:
     await raw_data_store.create_tree(store_id=store_id)
 
 
-@pytest.mark.parametrize(argnames=["length"], argvalues=[[length] for length in [*range(0, 32), *range(33, 48)]])
+@pytest.mark.parametrize(argnames=["length"], argvalues=[[length] for length in [*range(32), *range(33, 48)]])
 @pytest.mark.anyio
 async def test_create_store_fails_for_not_bytes32(raw_data_store: DataStore, length: int) -> None:
     bad_store_id = b"\0" * length
@@ -1355,13 +1355,13 @@ async def test_server_http_ban(
     async def mock_http_download(
         target_filename_path: Path,
         filename: str,
-        proxy_url: str,
+        proxy_url: Optional[str],
         server_info: ServerInfo,
         timeout: aiohttp.ClientTimeout,
         log: logging.Logger,
     ) -> None:
         if error:
-            raise aiohttp.ClientConnectionError()
+            raise aiohttp.ClientConnectionError
 
     start_timestamp = int(time.time())
     with monkeypatch.context() as m:
@@ -1885,7 +1885,7 @@ async def test_insert_from_delta_file(
     async def mock_http_download(
         target_filename_path: Path,
         filename: str,
-        proxy_url: str,
+        proxy_url: Optional[str],
         server_info: ServerInfo,
         timeout: int,
         log: logging.Logger,
@@ -1895,7 +1895,7 @@ async def test_insert_from_delta_file(
     async def mock_http_download_2(
         target_filename_path: Path,
         filename: str,
-        proxy_url: str,
+        proxy_url: Optional[str],
         server_info: ServerInfo,
         timeout: int,
         log: logging.Logger,

chia/_tests/core/farmer/test_farmer_api.py

@@ -17,8 +17,8 @@ from chia._tests.util.network_protocol_data import (
 )
 from chia.farmer.farmer_api import FarmerAPI
 from chia.protocols import farmer_protocol
+from chia.protocols.outbound_message import Message, NodeType
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.server.outbound_message import Message, NodeType
 from chia.util.hash import std_hash
 from chia.util.task_referencer import create_referenced_task
 
@@ -46,7 +46,7 @@ async def test_farmer_ignores_concurrent_duplicate_signage_points(
     assert ProtocolMessageTypes(response).name == "harvester_handshake"
 
     sp = farmer_protocol.NewSignagePoint(
-        std_hash(b"1"), std_hash(b"2"), std_hash(b"3"), uint64(1), uint64(1000000), uint8(2), uint32(1)
+        std_hash(b"1"), std_hash(b"2"), std_hash(b"3"), uint64(1), uint64(1000000), uint8(2), uint32(1), uint32(0)
     )
     await gather(
         farmer_api.new_signage_point(sp),