chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/wallet/simple_sync/test_simple_sync_protocol.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-from typing import List
 
 import pytest
 from clvm.casts import int_to_bytes
@@ -31,7 +30,7 @@ log = getLogger(__name__)
 zero_ph = bytes32(32 * b"\0")
 
 
-async def get_all_messages_in_queue(queue: asyncio.Queue[Message]) -> List[Message]:
+async def get_all_messages_in_queue(queue: asyncio.Queue[Message]) -> list[Message]:
     all_messages = []
     await asyncio.sleep(2)
     while not queue.empty():
@@ -54,9 +53,9 @@ async def test_subscribe_for_ph(simulator_and_wallet: OldSimulatorsAndWallets, s
     junk_ph = bytes32(32 * b"\a")
     fake_wallet_peer = fn_server.all_connections[peer_id]
     msg = wallet_protocol.RegisterForPhUpdates([zero_ph], uint32(0))
-    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
+    msg_response = await full_node_api.register_for_ph_updates(msg, fake_wallet_peer)
 
-    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_updates.value
     data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
     assert data_response.coin_states == []
 
@@ -69,8 +68,8 @@ async def test_subscribe_for_ph(simulator_and_wallet: OldSimulatorsAndWallets, s
             await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
 
     msg = wallet_protocol.RegisterForPhUpdates([zero_ph], uint32(0))
-    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
-    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    msg_response = await full_node_api.register_for_ph_updates(msg, fake_wallet_peer)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_updates.value
     data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
     # we have already subscribed to this puzzle hash, it will be ignored
     # we still receive the updates (see below)
@@ -102,7 +101,7 @@ async def test_subscribe_for_ph(simulator_and_wallet: OldSimulatorsAndWallets, s
     # Test subscribing to more coins
     one_ph = bytes32(32 * b"\1")
     msg = wallet_protocol.RegisterForPhUpdates([one_ph], uint32(0))
-    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
+    msg_response = await full_node_api.register_for_ph_updates(msg, fake_wallet_peer)
     peak = full_node_api.full_node.blockchain.get_peak()
 
     for i in range(num_blocks):
@@ -164,8 +163,8 @@ async def test_subscribe_for_ph(simulator_and_wallet: OldSimulatorsAndWallets, s
     assert funds == fn_amount
 
     msg_1 = wallet_protocol.RegisterForPhUpdates([puzzle_hash], uint32(0))
-    msg_response_1 = await full_node_api.register_interest_in_puzzle_hash(msg_1, fake_wallet_peer)
-    assert msg_response_1.type == ProtocolMessageTypes.respond_to_ph_update.value
+    msg_response_1 = await full_node_api.register_for_ph_updates(msg_1, fake_wallet_peer)
+    assert msg_response_1.type == ProtocolMessageTypes.respond_to_ph_updates.value
     data_response_1 = RespondToCoinUpdates.from_bytes(msg_response_1.data)
     assert len(data_response_1.coin_states) == 2 * num_blocks  # 2 per height farmer / pool reward
 
@@ -245,9 +244,9 @@ async def test_subscribe_for_coin_id(simulator_and_wallet: OldSimulatorsAndWalle
     coin_to_spend = my_coins[0].coin
 
     msg = wallet_protocol.RegisterForCoinUpdates([coin_to_spend.name()], uint32(0))
-    msg_response = await full_node_api.register_interest_in_coin(msg, fake_wallet_peer)
+    msg_response = await full_node_api.register_for_coin_updates(msg, fake_wallet_peer)
     assert msg_response is not None
-    assert msg_response.type == ProtocolMessageTypes.respond_to_coin_update.value
+    assert msg_response.type == ProtocolMessageTypes.respond_to_coin_updates.value
     data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
     assert data_response.coin_states[0].coin == coin_to_spend
 
@@ -287,9 +286,9 @@ async def test_subscribe_for_coin_id(simulator_and_wallet: OldSimulatorsAndWalle
     assert added_target is not None
 
     msg = wallet_protocol.RegisterForCoinUpdates([added_target.name()], uint32(0))
-    msg_response = await full_node_api.register_interest_in_coin(msg, fake_wallet_peer)
+    msg_response = await full_node_api.register_for_coin_updates(msg, fake_wallet_peer)
     assert msg_response is not None
-    assert msg_response.type == ProtocolMessageTypes.respond_to_coin_update.value
+    assert msg_response.type == ProtocolMessageTypes.respond_to_coin_updates.value
     data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
     assert len(data_response.coin_states) == 0
 
@@ -339,7 +338,7 @@ async def test_subscribe_for_ph_reorg(simulator_and_wallet: OldSimulatorsAndWall
         await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(zero_ph))
 
     msg = wallet_protocol.RegisterForPhUpdates([puzzle_hash], uint32(0))
-    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
+    msg_response = await full_node_api.register_for_ph_updates(msg, fake_wallet_peer)
     assert msg_response is not None
     await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(puzzle_hash))
 
@@ -360,7 +359,7 @@ async def test_subscribe_for_ph_reorg(simulator_and_wallet: OldSimulatorsAndWall
 
     all_messages = await get_all_messages_in_queue(incoming_queue)
 
-    coin_update_messages: List[CoinStateUpdate] = []
+    coin_update_messages: list[CoinStateUpdate] = []
     for message in all_messages:
         if message.type == ProtocolMessageTypes.coin_state_update.value:
             coin_state_update = CoinStateUpdate.from_bytes(message.data)
@@ -426,7 +425,7 @@ async def test_subscribe_for_coin_id_reorg(simulator_and_wallet: OldSimulatorsAn
 
     for coin_rec in coin_records:
         msg = wallet_protocol.RegisterForCoinUpdates([coin_rec.name], uint32(0))
-        msg_response = await full_node_api.register_interest_in_coin(msg, fake_wallet_peer)
+        msg_response = await full_node_api.register_for_coin_updates(msg, fake_wallet_peer)
         assert msg_response is not None
 
     fork_height = uint32(expected_height - num_blocks - 5)
@@ -438,7 +437,7 @@ async def test_subscribe_for_coin_id_reorg(simulator_and_wallet: OldSimulatorsAn
 
     all_messages = await get_all_messages_in_queue(incoming_queue)
 
-    coin_update_messages: List[CoinStateUpdate] = []
+    coin_update_messages: list[CoinStateUpdate] = []
     for message in all_messages:
         if message.type == ProtocolMessageTypes.coin_state_update.value:
             coin_state_update = CoinStateUpdate.from_bytes(message.data)
@@ -482,8 +481,8 @@ async def test_subscribe_for_hint(simulator_and_wallet: OldSimulatorsAndWallets,
 
     fake_wallet_peer = fn_server.all_connections[peer_id]
     msg = wallet_protocol.RegisterForPhUpdates([hint], uint32(0))
-    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
-    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    msg_response = await full_node_api.register_for_ph_updates(msg, fake_wallet_peer)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_updates.value
     data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
     assert len(data_response.coin_states) == 0
 
@@ -513,8 +512,8 @@ async def test_subscribe_for_hint(simulator_and_wallet: OldSimulatorsAndWallets,
     assert notified_state.items[0].coin == Coin(coin_spent.name(), hint_puzzle_hash, amount)
 
     msg = wallet_protocol.RegisterForPhUpdates([hint], uint32(0))
-    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
-    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    msg_response = await full_node_api.register_for_ph_updates(msg, fake_wallet_peer)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_updates.value
     response = RespondToCoinUpdates.from_bytes(msg_response.data)
     # we have already subscribed to this puzzle hash. The full node will
     # ignore the duplicate
@@ -549,8 +548,8 @@ async def test_subscribe_for_puzzle_hash_coin_hint_duplicates(
     await full_node_api.process_spend_bundles(bundles=[tx])
     # Query the coin states and make sure it doesn't contain duplicated entries
     msg = wallet_protocol.RegisterForPhUpdates([ph], uint32(0))
-    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, wallet_connection)
-    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    msg_response = await full_node_api.register_for_ph_updates(msg, wallet_connection)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_updates.value
     response = RespondToCoinUpdates.from_bytes(msg_response.data)
     assert len(response.coin_states) > 0
     assert len(set(response.coin_states)) == len(response.coin_states)
@@ -587,10 +586,10 @@ async def test_subscribe_for_hint_long_sync(
     fake_wallet_peer = fn_server.all_connections[peer_id]
     fake_wallet_peer_1 = fn_server_1.all_connections[peer_id_1]
     msg = wallet_protocol.RegisterForPhUpdates([hint], uint32(0))
-    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, fake_wallet_peer)
-    await full_node_api_1.register_interest_in_puzzle_hash(msg, fake_wallet_peer_1)
+    msg_response = await full_node_api.register_for_ph_updates(msg, fake_wallet_peer)
+    await full_node_api_1.register_for_ph_updates(msg, fake_wallet_peer_1)
 
-    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_updates.value
     data_response = RespondToCoinUpdates.from_bytes(msg_response.data)
     assert len(data_response.coin_states) == 0
 
@@ -621,7 +620,7 @@ async def test_subscribe_for_hint_long_sync(
     all_messages = await get_all_messages_in_queue(incoming_queue)
     all_messages_1 = await get_all_messages_in_queue(incoming_queue_1)
 
-    def check_messages_for_hint(messages: List[Message]) -> None:
+    def check_messages_for_hint(messages: list[Message]) -> None:
         notified_state = None
 
         for message in messages:
@@ -644,7 +643,7 @@ async def test_ph_subscribe_limits(simulator_and_wallet: OldSimulatorsAndWallets
     _, server_2 = wallets[0]
     fn_server = full_node_api.full_node.server
     await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
-    con = list(fn_server.all_connections.values())[0]
+    con = next(iter(fn_server.all_connections.values()))
     phs = []
     phs.append(bytes32(32 * b"\0"))
     phs.append(bytes32(32 * b"\1"))
@@ -656,8 +655,8 @@ async def test_ph_subscribe_limits(simulator_and_wallet: OldSimulatorsAndWallets
     full_node_api.full_node.config["max_subscribe_items"] = 2
     assert full_node_api.is_trusted(con) is False
     msg = wallet_protocol.RegisterForPhUpdates(phs, uint32(0))
-    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, con)
-    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    msg_response = await full_node_api.register_for_ph_updates(msg, con)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_updates.value
     s = full_node_api.full_node.subscriptions
     assert s.puzzle_subscription_count() == 2
     assert s.has_puzzle_subscription(phs[0])
@@ -667,8 +666,8 @@ async def test_ph_subscribe_limits(simulator_and_wallet: OldSimulatorsAndWallets
     full_node_api.full_node.config["trusted_max_subscribe_items"] = 4
     full_node_api.full_node.config["trusted_peers"] = {server_2.node_id.hex(): server_2.node_id.hex()}
     assert full_node_api.is_trusted(con) is True
-    msg_response = await full_node_api.register_interest_in_puzzle_hash(msg, con)
-    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_update.value
+    msg_response = await full_node_api.register_for_ph_updates(msg, con)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_ph_updates.value
     assert s.puzzle_subscription_count() == 4
     assert s.has_puzzle_subscription(phs[0])
     assert s.has_puzzle_subscription(phs[1])
@@ -685,7 +684,7 @@ async def test_coin_subscribe_limits(simulator_and_wallet: OldSimulatorsAndWalle
     _, server_2 = wallets[0]
     fn_server = full_node_api.full_node.server
     await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
-    con = list(fn_server.all_connections.values())[0]
+    con = next(iter(fn_server.all_connections.values()))
     coins = []
     coins.append(bytes32(32 * b"\0"))
     coins.append(bytes32(32 * b"\1"))
@@ -697,8 +696,8 @@ async def test_coin_subscribe_limits(simulator_and_wallet: OldSimulatorsAndWalle
     full_node_api.full_node.config["max_subscribe_items"] = 2
     assert full_node_api.is_trusted(con) is False
     msg = wallet_protocol.RegisterForCoinUpdates(coins, uint32(0))
-    msg_response = await full_node_api.register_interest_in_coin(msg, con)
-    assert msg_response.type == ProtocolMessageTypes.respond_to_coin_update.value
+    msg_response = await full_node_api.register_for_coin_updates(msg, con)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_coin_updates.value
     s = full_node_api.full_node.subscriptions
     assert s.coin_subscription_count() == 2
     assert s.has_coin_subscription(coins[0])
@@ -708,8 +707,8 @@ async def test_coin_subscribe_limits(simulator_and_wallet: OldSimulatorsAndWalle
     full_node_api.full_node.config["trusted_max_subscribe_items"] = 4
     full_node_api.full_node.config["trusted_peers"] = {server_2.node_id.hex(): server_2.node_id.hex()}
     assert full_node_api.is_trusted(con) is True
-    msg_response = await full_node_api.register_interest_in_coin(msg, con)
-    assert msg_response.type == ProtocolMessageTypes.respond_to_coin_update.value
+    msg_response = await full_node_api.register_for_coin_updates(msg, con)
+    assert msg_response.type == ProtocolMessageTypes.respond_to_coin_updates.value
     assert s.coin_subscription_count() == 4
     assert s.has_coin_subscription(coins[0])
     assert s.has_coin_subscription(coins[1])