chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7rc2__py3-none-any.whl

chia/seeder/crawler.py

@@ -180,7 +180,7 @@ class Crawler:
                     uint64(0),
                     uint32(0),
                     uint64(0),
-                    uint64(int(time.time())),
+                    uint64(time.time()),
                     uint64(0),
                     "undefined",
                     uint64(0),
@@ -248,7 +248,7 @@ class Crawler:
                                 uint64(0),
                                 uint32(0),
                                 uint64(0),
-                                uint64(int(time.time())),
+                                uint64(time.time()),
                                 uint64(response_peer.timestamp),
                                 "undefined",
                                 uint64(0),

chia/seeder/crawler_service.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from chia.seeder.crawler import Crawler
+from chia.seeder.crawler_api import CrawlerAPI
+from chia.seeder.crawler_rpc_api import CrawlerRpcApi
+from chia.server.start_service import Service
+
+CrawlerService = Service[Crawler, CrawlerAPI, CrawlerRpcApi]

chia/seeder/start_crawler.py

@@ -15,7 +15,7 @@ from chia.protocols.outbound_message import NodeType
 from chia.seeder.crawler import Crawler
 from chia.seeder.crawler_api import CrawlerAPI
 from chia.seeder.crawler_rpc_api import CrawlerRpcApi
-from chia.server.aliases import CrawlerService
+from chia.seeder.crawler_service import CrawlerService
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import RpcInfo, Service, async_run
 from chia.util.chia_logging import initialize_service_logging

chia/server/address_manager.py

@@ -129,8 +129,8 @@ class ExtendedPeerInfo:
     def from_string(cls, peer_str: str) -> ExtendedPeerInfo:
         blobs = peer_str.split(" ")
         assert len(blobs) == 5
-        peer_info = TimestampedPeerInfo(blobs[0], uint16(int(blobs[1])), uint64(int(blobs[2])))
-        src_peer = PeerInfo(blobs[3], uint16(int(blobs[4])))
+        peer_info = TimestampedPeerInfo(blobs[0], uint16(blobs[1]), uint64(blobs[2]))
+        src_peer = PeerInfo(blobs[3], uint16(blobs[4]))
         return cls(peer_info, src_peer)
 
     def get_tried_bucket(self, key: int) -> int:
@@ -177,7 +177,7 @@ class ExtendedPeerInfo:
 
     def is_terrible(self, now: Optional[int] = None) -> bool:
         if now is None:
-            now = int(math.floor(time.time()))
+            now = math.floor(time.time())
         # never remove things tried in the last minute
         if self.last_try > 0 and self.last_try >= now - 60:
             return False
@@ -202,7 +202,7 @@ class ExtendedPeerInfo:
 
     def get_selection_chance(self, now: Optional[int] = None) -> float:
         if now is None:
-            now = int(math.floor(time.time()))
+            now = math.floor(time.time())
         chance = 1.0
         since_last_try = max(now - self.last_try, 0)
         # deprioritize very recent attempts away
@@ -371,9 +371,8 @@ class AddressManager:
         if value == -1:
             if (row, col) in self.used_new_matrix_positions:
                 self.used_new_matrix_positions.remove((row, col))
-        else:
-            if (row, col) not in self.used_new_matrix_positions:
-                self.used_new_matrix_positions.add((row, col))
+        elif (row, col) not in self.used_new_matrix_positions:
+            self.used_new_matrix_positions.add((row, col))
 
     # Use only this method for modifying tried matrix.
     def _set_tried_matrix(self, row: int, col: int, value: int) -> None:
@@ -381,9 +380,8 @@ class AddressManager:
         if value == -1:
             if (row, col) in self.used_tried_matrix_positions:
                 self.used_tried_matrix_positions.remove((row, col))
-        else:
-            if (row, col) not in self.used_tried_matrix_positions:
-                self.used_tried_matrix_positions.add((row, col))
+        elif (row, col) not in self.used_tried_matrix_positions:
+            self.used_tried_matrix_positions.add((row, col))
 
     def load_used_table_positions(self) -> None:
         self.used_new_matrix_positions = set()
@@ -587,10 +585,9 @@ class AddressManager:
                 info.ref_count += 1
                 if node_id is not None:
                     self._set_new_matrix(new_bucket, new_bucket_pos, node_id)
-            else:
-                if info.ref_count == 0:
-                    if node_id is not None:
-                        self.delete_new_entry_(node_id)
+            elif info.ref_count == 0:
+                if node_id is not None:
+                    self.delete_new_entry_(node_id)
         return is_unique
 
     def attempt_(self, addr: PeerInfo, count_failures: bool, timestamp: int) -> None:
@@ -737,7 +734,7 @@ class AddressManager:
         return addr
 
     def cleanup(self, max_timestamp_difference: int, max_consecutive_failures: int) -> None:
-        now = int(math.floor(time.time()))
+        now = math.floor(time.time())
         for bucket in range(NEW_BUCKET_COUNT):
             for pos in range(BUCKET_SIZE):
                 if self.new_matrix[bucket][pos] != -1:

chia/server/introducer_peers.py

@@ -48,7 +48,7 @@ class IntroducerPeers:
             return False
 
         p = VettedPeer(peer.host, peer.port)
-        p.time_added = uint64(int(time.time()))
+        p.time_added = uint64(time.time())
 
         if p in self._peers:
             return True

chia/server/node_discovery.py

@@ -119,7 +119,7 @@ class FullNodeDiscovery:
             timestamped_peer_info = TimestampedPeerInfo(
                 peer.peer_info.host,
                 peer.peer_server_port,
-                uint64(int(time.time())),
+                uint64(time.time()),
             )
             await self.address_manager.add_to_new_table([timestamped_peer_info], peer.get_peer_info(), 0)
             if self.relay_queue is not None:
@@ -228,12 +228,11 @@ class FullNodeDiscovery:
             if self.server.is_duplicate_or_self_connection(addr):
                 # Mark it as a softer attempt, without counting the failures.
                 await self.address_manager.attempt(addr, False)
+            elif client_connected is True:
+                await self.address_manager.mark_good(addr)
+                await self.address_manager.connect(addr)
             else:
-                if client_connected is True:
-                    await self.address_manager.mark_good(addr)
-                    await self.address_manager.connect(addr)
-                else:
-                    await self.address_manager.attempt(addr, True)
+                await self.address_manager.attempt(addr, True)
             self.pending_outbound_connections.remove(addr.host)
         except Exception as e:
             if addr.host in self.pending_outbound_connections:
@@ -247,7 +246,7 @@ class FullNodeDiscovery:
         dns_server_index: int = 0
         tried_all_dns_servers: bool = False
         local_peerinfo: Optional[PeerInfo] = await self.server.get_peer_info()
-        last_timestamp_local_info: uint64 = uint64(int(time.time()))
+        last_timestamp_local_info: uint64 = uint64(time.time())
         last_collision_timestamp = 0
 
         if self.initial_wait > 0:
@@ -372,7 +371,7 @@ class FullNodeDiscovery:
                         continue
                     if time.time() - last_timestamp_local_info > 1800 or local_peerinfo is None:
                         local_peerinfo = await self.server.get_peer_info()
-                        last_timestamp_local_info = uint64(int(time.time()))
+                        last_timestamp_local_info = uint64(time.time())
                     if local_peerinfo is not None and addr == local_peerinfo:
                         continue
                     got_peer = True
@@ -465,7 +464,7 @@ class FullNodeDiscovery:
                 current_peer = TimestampedPeerInfo(
                     peer.host,
                     peer.port,
-                    uint64(int(time.time() - 5 * 24 * 60 * 60)),
+                    uint64(time.time() - 5 * 24 * 60 * 60),
                 )
             else:
                 current_peer = peer
@@ -534,7 +533,7 @@ class FullNodePeers(FullNodeDiscovery):
                     TimestampedPeerInfo(
                         peer.host,
                         peer.port,
-                        uint64(int(time.time())),
+                        uint64(time.time()),
                     )
                 ]
                 msg = make_msg(

chia/server/rate_limit_numbers.py

@@ -1,21 +1,22 @@
 # All of these rate limits scale with the number of transactions so the aggregate amounts are higher
 from __future__ import annotations
 
-import copy
 import dataclasses
-import functools
-from typing import Any, Optional
+from typing import Optional, Union
 
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Capability
 
-compose_rate_limits_cache: dict[int, dict[str, Any]] = {}
+compose_rate_limits_cache: dict[int, dict[ProtocolMessageTypes, Union[RLSettings, Unlimited]]] = {}
 
 
 # this class is used to configure the *rate* limit for a message type. The
 # limits are counts and size per 60 seconds.
 @dataclasses.dataclass(frozen=True)
 class RLSettings:
+    # if true, messages affect and are limited by the per connection aggregate limiter,
+    # which affects messages across message types
+    aggregate_limit: bool
     frequency: int  # Max request per time period (ie 1 min)
     max_size: int  # Max size of each request
     max_total_size: Optional[int] = None  # Max cumulative size of all requests in that period
@@ -24,191 +25,179 @@ class RLSettings:
 # this class is used to indicate that a message type is not subject to a rate
 # limit, but just a per-message size limit. This may be appropriate for response
 # messages that are implicitly limited by their corresponding request message
+# Unlimited message types are also not subject to the overall limit across all
+# messages (just like messages in the "tx" category)
 @dataclasses.dataclass(frozen=True)
 class Unlimited:
     max_size: int  # Max size of each request
 
 
-def get_rate_limits_to_use(our_capabilities: list[Capability], peer_capabilities: list[Capability]) -> dict[str, Any]:
+# for the aggregate limit, not all fields of RLSettings are used. Only "frequency" and "max_total_size"
+aggregate_limit = RLSettings(
+    aggregate_limit=False,
+    frequency=1000,
+    max_size=0,
+    max_total_size=100 * 1024 * 1024,
+)
+
+
+def get_rate_limits_to_use(
+    our_capabilities: list[Capability], peer_capabilities: list[Capability]
+) -> tuple[dict[ProtocolMessageTypes, Union[RLSettings, Unlimited]], RLSettings]:
     # This will use the newest possible rate limits that both peers support. At this time there are only two
     # options, v1 and v2.
 
     if Capability.RATE_LIMITS_V2 in our_capabilities and Capability.RATE_LIMITS_V2 in peer_capabilities:
         # Use V2 rate limits
         if 2 in compose_rate_limits_cache:
-            return compose_rate_limits_cache[2]
-        composed = compose_rate_limits(rate_limits[1], rate_limits[2])
+            return compose_rate_limits_cache[2], aggregate_limit
+        composed = {
+            **rate_limits[1],
+            **rate_limits[2],
+        }
         compose_rate_limits_cache[2] = composed
-        return composed
+        return composed, aggregate_limit
     else:
         # Use V1 rate limits
-        return rate_limits[1]
-
-
-def compose_rate_limits(old_rate_limits: dict[str, Any], new_rate_limits: dict[str, Any]) -> dict[str, Any]:
-    # Composes two rate limits dicts, so that the newer values override the older values
-    final_rate_limits: dict[str, Any] = copy.deepcopy(new_rate_limits)
-    categories: list[str] = ["rate_limits_tx", "rate_limits_other"]
-    all_new_msgs_lists: list[list[ProtocolMessageTypes]] = [
-        list(new_rate_limits[category].keys()) for category in categories
-    ]
-    all_new_msgs: list[ProtocolMessageTypes] = functools.reduce(lambda a, b: a + b, all_new_msgs_lists)
-    for old_cat, mapping in old_rate_limits.items():
-        if old_cat in categories:
-            for old_protocol_msg, old_rate_limit_value in mapping.items():
-                if old_protocol_msg not in all_new_msgs:
-                    if old_cat not in final_rate_limits:
-                        final_rate_limits[old_cat] = {}
-                    final_rate_limits[old_cat][old_protocol_msg] = old_rate_limit_value
-    return final_rate_limits
+        return rate_limits[1], aggregate_limit
 
 
 # Each number in this dict corresponds to a specific version of rate limits (1, 2,  etc).
 # Version 1 includes the original limits for chia software from versions 1.0 to 1.4.
-rate_limits = {
+rate_limits: dict[int, dict[ProtocolMessageTypes, Union[RLSettings, Unlimited]]] = {
     1: {
-        "default_settings": RLSettings(100, 1024 * 1024, 100 * 1024 * 1024),
-        "non_tx_freq": 1000,  # There is also a freq limit for many requests
-        "non_tx_max_total_size": 100 * 1024 * 1024,  # There is also a size limit for many requests
-        # All transaction related apis also have an aggregate limit
-        "rate_limits_tx": {
-            ProtocolMessageTypes.new_transaction: RLSettings(5000, 100, 5000 * 100),
-            ProtocolMessageTypes.request_transaction: RLSettings(5000, 100, 5000 * 100),
-            ProtocolMessageTypes.respond_transaction: RLSettings(
-                5000, 1 * 1024 * 1024, 20 * 1024 * 1024
-            ),  # TODO: check this
-            ProtocolMessageTypes.send_transaction: RLSettings(5000, 1024 * 1024),
-            ProtocolMessageTypes.transaction_ack: RLSettings(5000, 2048),
-        },
+        ProtocolMessageTypes.new_transaction: RLSettings(False, 5000, 100, 5000 * 100),
+        ProtocolMessageTypes.request_transaction: RLSettings(False, 5000, 100, 5000 * 100),
+        # TODO: check this
+        ProtocolMessageTypes.respond_transaction: RLSettings(False, 5000, 1 * 1024 * 1024, 20 * 1024 * 1024),
+        ProtocolMessageTypes.send_transaction: RLSettings(False, 5000, 1024 * 1024),
+        ProtocolMessageTypes.transaction_ack: RLSettings(False, 5000, 2048),
         # All non-transaction apis also have an aggregate limit
-        "rate_limits_other": {
-            ProtocolMessageTypes.handshake: RLSettings(5, 10 * 1024, 5 * 10 * 1024),
-            ProtocolMessageTypes.harvester_handshake: RLSettings(5, 1024 * 1024),
-            ProtocolMessageTypes.new_signage_point_harvester: RLSettings(100, 4886),  # Size with 100 pool list
-            ProtocolMessageTypes.new_proof_of_space: RLSettings(100, 2048),
-            ProtocolMessageTypes.request_signatures: RLSettings(100, 2048),
-            ProtocolMessageTypes.respond_signatures: RLSettings(100, 2048),
-            ProtocolMessageTypes.new_signage_point: RLSettings(200, 2048),
-            ProtocolMessageTypes.declare_proof_of_space: RLSettings(100, 10 * 1024),
-            ProtocolMessageTypes.request_signed_values: RLSettings(100, 10 * 1024),
-            ProtocolMessageTypes.farming_info: RLSettings(100, 1024),
-            ProtocolMessageTypes.signed_values: RLSettings(100, 1024),
-            ProtocolMessageTypes.new_peak_timelord: RLSettings(100, 20 * 1024),
-            ProtocolMessageTypes.new_unfinished_block_timelord: RLSettings(100, 10 * 1024),
-            ProtocolMessageTypes.new_signage_point_vdf: RLSettings(100, 100 * 1024),
-            ProtocolMessageTypes.new_infusion_point_vdf: RLSettings(100, 100 * 1024),
-            ProtocolMessageTypes.new_end_of_sub_slot_vdf: RLSettings(100, 100 * 1024),
-            ProtocolMessageTypes.request_compact_proof_of_time: RLSettings(100, 10 * 1024),
-            ProtocolMessageTypes.respond_compact_proof_of_time: RLSettings(100, 100 * 1024),
-            ProtocolMessageTypes.new_peak: RLSettings(200, 512),
-            ProtocolMessageTypes.request_proof_of_weight: RLSettings(5, 100),
-            ProtocolMessageTypes.respond_proof_of_weight: RLSettings(5, 50 * 1024 * 1024, 100 * 1024 * 1024),
-            ProtocolMessageTypes.request_block: RLSettings(200, 100),
-            ProtocolMessageTypes.reject_block: Unlimited(100),
-            ProtocolMessageTypes.request_blocks: RLSettings(500, 100),
-            ProtocolMessageTypes.respond_blocks: Unlimited(50 * 1024 * 1024),
-            ProtocolMessageTypes.reject_blocks: Unlimited(100),
-            ProtocolMessageTypes.respond_block: Unlimited(2 * 1024 * 1024),
-            ProtocolMessageTypes.new_unfinished_block: RLSettings(200, 100),
-            ProtocolMessageTypes.request_unfinished_block: RLSettings(200, 100),
-            ProtocolMessageTypes.new_unfinished_block2: RLSettings(200, 100),
-            ProtocolMessageTypes.request_unfinished_block2: RLSettings(200, 100),
-            ProtocolMessageTypes.respond_unfinished_block: RLSettings(200, 2 * 1024 * 1024, 10 * 2 * 1024 * 1024),
-            ProtocolMessageTypes.new_signage_point_or_end_of_sub_slot: RLSettings(200, 200),
-            ProtocolMessageTypes.request_signage_point_or_end_of_sub_slot: RLSettings(200, 200),
-            ProtocolMessageTypes.respond_signage_point: RLSettings(200, 50 * 1024),
-            ProtocolMessageTypes.respond_end_of_sub_slot: RLSettings(100, 50 * 1024),
-            ProtocolMessageTypes.request_mempool_transactions: RLSettings(5, 1024 * 1024),
-            ProtocolMessageTypes.request_compact_vdf: RLSettings(200, 1024),
-            ProtocolMessageTypes.respond_compact_vdf: RLSettings(200, 100 * 1024),
-            ProtocolMessageTypes.new_compact_vdf: RLSettings(100, 1024),
-            ProtocolMessageTypes.request_peers: RLSettings(10, 100),
-            ProtocolMessageTypes.respond_peers: RLSettings(10, 1 * 1024 * 1024),
-            ProtocolMessageTypes.request_puzzle_solution: RLSettings(1000, 100),
-            ProtocolMessageTypes.respond_puzzle_solution: RLSettings(1000, 1024 * 1024),
-            ProtocolMessageTypes.reject_puzzle_solution: RLSettings(1000, 100),
-            ProtocolMessageTypes.new_peak_wallet: RLSettings(200, 300),
-            ProtocolMessageTypes.request_block_header: RLSettings(500, 100),
-            ProtocolMessageTypes.respond_block_header: RLSettings(500, 500 * 1024),
-            ProtocolMessageTypes.reject_header_request: RLSettings(500, 100),
-            ProtocolMessageTypes.request_removals: RLSettings(500, 50 * 1024, 10 * 1024 * 1024),
-            ProtocolMessageTypes.respond_removals: RLSettings(500, 1024 * 1024, 10 * 1024 * 1024),
-            ProtocolMessageTypes.reject_removals_request: RLSettings(500, 100),
-            ProtocolMessageTypes.request_additions: RLSettings(500, 1024 * 1024, 10 * 1024 * 1024),
-            ProtocolMessageTypes.respond_additions: RLSettings(500, 1024 * 1024, 10 * 1024 * 1024),
-            ProtocolMessageTypes.reject_additions_request: RLSettings(500, 100),
-            ProtocolMessageTypes.request_header_blocks: RLSettings(500, 100),
-            ProtocolMessageTypes.reject_header_blocks: RLSettings(100, 100),
-            ProtocolMessageTypes.respond_header_blocks: RLSettings(500, 2 * 1024 * 1024, 100 * 1024 * 1024),
-            ProtocolMessageTypes.request_peers_introducer: RLSettings(100, 100),
-            ProtocolMessageTypes.respond_peers_introducer: RLSettings(100, 1024 * 1024),
-            ProtocolMessageTypes.farm_new_block: RLSettings(200, 200),
-            ProtocolMessageTypes.request_plots: RLSettings(10, 10 * 1024 * 1024),
-            ProtocolMessageTypes.respond_plots: RLSettings(10, 100 * 1024 * 1024),
-            ProtocolMessageTypes.plot_sync_start: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.plot_sync_loaded: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.plot_sync_removed: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.plot_sync_invalid: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.plot_sync_keys_missing: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.plot_sync_duplicates: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.plot_sync_done: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.plot_sync_response: RLSettings(3000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.coin_state_update: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.register_for_ph_updates: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.respond_to_ph_updates: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.register_for_coin_updates: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.respond_to_coin_updates: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.request_remove_puzzle_subscriptions: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.respond_remove_puzzle_subscriptions: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.request_remove_coin_subscriptions: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.respond_remove_coin_subscriptions: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.request_puzzle_state: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.respond_puzzle_state: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.reject_puzzle_state: RLSettings(200, 100),
-            ProtocolMessageTypes.request_coin_state: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.respond_coin_state: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.reject_coin_state: RLSettings(200, 100),
-            ProtocolMessageTypes.mempool_items_added: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.mempool_items_removed: RLSettings(1000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.request_cost_info: RLSettings(1000, 100),
-            ProtocolMessageTypes.respond_cost_info: RLSettings(1000, 1024),
-            ProtocolMessageTypes.request_ses_hashes: RLSettings(2000, 1 * 1024 * 1024),
-            ProtocolMessageTypes.respond_ses_hashes: RLSettings(2000, 1 * 1024 * 1024),
-            ProtocolMessageTypes.request_children: RLSettings(2000, 1024 * 1024),
-            ProtocolMessageTypes.respond_children: RLSettings(2000, 1 * 1024 * 1024),
-        },
+        ProtocolMessageTypes.handshake: RLSettings(True, 5, 10 * 1024, 5 * 10 * 1024),
+        ProtocolMessageTypes.harvester_handshake: RLSettings(True, 5, 1024 * 1024),
+        ProtocolMessageTypes.new_signage_point_harvester: RLSettings(True, 100, 4886),  # Size with 100 pool list
+        ProtocolMessageTypes.new_proof_of_space: RLSettings(True, 100, 2048),
+        ProtocolMessageTypes.request_signatures: RLSettings(True, 100, 2048),
+        ProtocolMessageTypes.respond_signatures: RLSettings(True, 100, 2048),
+        ProtocolMessageTypes.new_signage_point: RLSettings(True, 200, 2048),
+        ProtocolMessageTypes.declare_proof_of_space: RLSettings(True, 100, 10 * 1024),
+        ProtocolMessageTypes.request_signed_values: RLSettings(True, 100, 10 * 1024),
+        ProtocolMessageTypes.farming_info: RLSettings(True, 100, 1024),
+        ProtocolMessageTypes.signed_values: RLSettings(True, 100, 1024),
+        ProtocolMessageTypes.new_peak_timelord: RLSettings(True, 100, 20 * 1024),
+        ProtocolMessageTypes.new_unfinished_block_timelord: RLSettings(True, 100, 10 * 1024),
+        ProtocolMessageTypes.new_signage_point_vdf: RLSettings(True, 100, 100 * 1024),
+        ProtocolMessageTypes.new_infusion_point_vdf: RLSettings(True, 100, 100 * 1024),
+        ProtocolMessageTypes.new_end_of_sub_slot_vdf: RLSettings(True, 100, 100 * 1024),
+        ProtocolMessageTypes.request_compact_proof_of_time: RLSettings(True, 100, 10 * 1024),
+        ProtocolMessageTypes.respond_compact_proof_of_time: RLSettings(True, 100, 100 * 1024),
+        ProtocolMessageTypes.new_peak: RLSettings(True, 200, 512),
+        ProtocolMessageTypes.request_proof_of_weight: RLSettings(True, 5, 100),
+        ProtocolMessageTypes.respond_proof_of_weight: RLSettings(True, 5, 50 * 1024 * 1024, 100 * 1024 * 1024),
+        ProtocolMessageTypes.request_block: RLSettings(True, 200, 100),
+        ProtocolMessageTypes.reject_block: Unlimited(100),
+        ProtocolMessageTypes.request_blocks: RLSettings(True, 500, 100),
+        ProtocolMessageTypes.respond_blocks: Unlimited(50 * 1024 * 1024),
+        ProtocolMessageTypes.reject_blocks: Unlimited(100),
+        ProtocolMessageTypes.respond_block: Unlimited(2 * 1024 * 1024),
+        ProtocolMessageTypes.new_unfinished_block: RLSettings(True, 200, 100),
+        ProtocolMessageTypes.request_unfinished_block: RLSettings(True, 200, 100),
+        ProtocolMessageTypes.new_unfinished_block2: RLSettings(True, 200, 100),
+        ProtocolMessageTypes.request_unfinished_block2: RLSettings(True, 200, 100),
+        ProtocolMessageTypes.respond_unfinished_block: RLSettings(True, 200, 2 * 1024 * 1024, 10 * 2 * 1024 * 1024),
+        ProtocolMessageTypes.new_signage_point_or_end_of_sub_slot: RLSettings(True, 200, 200),
+        ProtocolMessageTypes.request_signage_point_or_end_of_sub_slot: RLSettings(True, 200, 200),
+        ProtocolMessageTypes.respond_signage_point: RLSettings(True, 200, 50 * 1024),
+        ProtocolMessageTypes.respond_end_of_sub_slot: RLSettings(True, 100, 50 * 1024),
+        ProtocolMessageTypes.request_mempool_transactions: RLSettings(True, 5, 1024 * 1024),
+        ProtocolMessageTypes.request_compact_vdf: RLSettings(True, 200, 1024),
+        ProtocolMessageTypes.respond_compact_vdf: RLSettings(True, 200, 100 * 1024),
+        ProtocolMessageTypes.new_compact_vdf: RLSettings(True, 100, 1024),
+        ProtocolMessageTypes.request_peers: RLSettings(True, 10, 100),
+        ProtocolMessageTypes.respond_peers: RLSettings(True, 10, 1 * 1024 * 1024),
+        ProtocolMessageTypes.request_puzzle_solution: RLSettings(True, 1000, 100),
+        ProtocolMessageTypes.respond_puzzle_solution: RLSettings(True, 1000, 1024 * 1024),
+        ProtocolMessageTypes.reject_puzzle_solution: RLSettings(True, 1000, 100),
+        ProtocolMessageTypes.none_response: RLSettings(False, 500, 100),
+        ProtocolMessageTypes.new_peak_wallet: RLSettings(True, 200, 300),
+        ProtocolMessageTypes.request_block_header: RLSettings(True, 500, 100),
+        ProtocolMessageTypes.respond_block_header: RLSettings(True, 500, 500 * 1024),
+        ProtocolMessageTypes.reject_header_request: RLSettings(True, 500, 100),
+        ProtocolMessageTypes.request_block_headers: RLSettings(False, 5000, 100),
+        ProtocolMessageTypes.reject_block_headers: RLSettings(False, 1000, 100),
+        ProtocolMessageTypes.respond_block_headers: RLSettings(False, 5000, 2 * 1024 * 1024),
+        ProtocolMessageTypes.request_removals: RLSettings(True, 500, 50 * 1024, 10 * 1024 * 1024),
+        ProtocolMessageTypes.respond_removals: RLSettings(True, 500, 1024 * 1024, 10 * 1024 * 1024),
+        ProtocolMessageTypes.reject_removals_request: RLSettings(True, 500, 100),
+        ProtocolMessageTypes.request_additions: RLSettings(True, 500, 1024 * 1024, 10 * 1024 * 1024),
+        ProtocolMessageTypes.respond_additions: RLSettings(True, 500, 1024 * 1024, 10 * 1024 * 1024),
+        ProtocolMessageTypes.reject_additions_request: RLSettings(True, 500, 100),
+        ProtocolMessageTypes.request_header_blocks: RLSettings(True, 500, 100),
+        ProtocolMessageTypes.reject_header_blocks: RLSettings(True, 100, 100),
+        ProtocolMessageTypes.respond_header_blocks: RLSettings(True, 500, 2 * 1024 * 1024, 100 * 1024 * 1024),
+        ProtocolMessageTypes.request_peers_introducer: RLSettings(True, 100, 100),
+        ProtocolMessageTypes.respond_peers_introducer: RLSettings(True, 100, 1024 * 1024),
+        ProtocolMessageTypes.farm_new_block: RLSettings(True, 200, 200),
+        ProtocolMessageTypes.request_plots: RLSettings(True, 10, 10 * 1024 * 1024),
+        ProtocolMessageTypes.respond_plots: RLSettings(True, 10, 100 * 1024 * 1024),
+        ProtocolMessageTypes.plot_sync_start: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.plot_sync_loaded: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.plot_sync_removed: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.plot_sync_invalid: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.plot_sync_keys_missing: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.plot_sync_duplicates: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.plot_sync_done: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.plot_sync_response: RLSettings(True, 3000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.coin_state_update: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.register_for_ph_updates: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.respond_to_ph_updates: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.register_for_coin_updates: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.respond_to_coin_updates: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.request_remove_puzzle_subscriptions: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.respond_remove_puzzle_subscriptions: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.request_remove_coin_subscriptions: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.respond_remove_coin_subscriptions: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.request_puzzle_state: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.respond_puzzle_state: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.reject_puzzle_state: RLSettings(True, 200, 100),
+        ProtocolMessageTypes.request_coin_state: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.respond_coin_state: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.reject_coin_state: RLSettings(True, 200, 100),
+        ProtocolMessageTypes.mempool_items_added: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.mempool_items_removed: RLSettings(True, 1000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.request_cost_info: RLSettings(True, 1000, 100),
+        ProtocolMessageTypes.respond_cost_info: RLSettings(True, 1000, 1024),
+        ProtocolMessageTypes.request_ses_hashes: RLSettings(True, 2000, 1 * 1024 * 1024),
+        ProtocolMessageTypes.respond_ses_hashes: RLSettings(True, 2000, 1 * 1024 * 1024),
+        ProtocolMessageTypes.request_children: RLSettings(True, 2000, 1024 * 1024),
+        ProtocolMessageTypes.respond_children: RLSettings(True, 2000, 1 * 1024 * 1024),
+        ProtocolMessageTypes.error: RLSettings(False, 50000, 100),
+        ProtocolMessageTypes.request_fee_estimates: RLSettings(True, 10, 100),
+        ProtocolMessageTypes.respond_fee_estimates: RLSettings(True, 10, 100),
+        ProtocolMessageTypes.solve: RLSettings(False, 120, 1024),
+        ProtocolMessageTypes.solution_response: RLSettings(False, 120, 1024),
+        ProtocolMessageTypes.partial_proofs: RLSettings(False, 120, 3 * 1024),
     },
     2: {
-        "default_settings": RLSettings(100, 1024 * 1024, 100 * 1024 * 1024),
-        "non_tx_freq": 1000,  # There is also a freq limit for many requests
-        "non_tx_max_total_size": 100 * 1024 * 1024,  # There is also a size limit for many requests
-        "rate_limits_tx": {
-            ProtocolMessageTypes.request_block_header: RLSettings(500, 100),
-            ProtocolMessageTypes.respond_block_header: RLSettings(500, 500 * 1024),
-            ProtocolMessageTypes.reject_header_request: RLSettings(500, 100),
-            ProtocolMessageTypes.request_removals: RLSettings(5000, 50 * 1024, 10 * 1024 * 1024),
-            ProtocolMessageTypes.respond_removals: RLSettings(5000, 1024 * 1024, 10 * 1024 * 1024),
-            ProtocolMessageTypes.reject_removals_request: RLSettings(500, 100),
-            ProtocolMessageTypes.request_additions: RLSettings(50000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.respond_additions: RLSettings(50000, 100 * 1024 * 1024),
-            ProtocolMessageTypes.reject_additions_request: RLSettings(500, 100),
-            ProtocolMessageTypes.reject_header_blocks: RLSettings(1000, 100),
-            ProtocolMessageTypes.respond_header_blocks: RLSettings(5000, 2 * 1024 * 1024),
-            ProtocolMessageTypes.request_block_headers: RLSettings(5000, 100),
-            ProtocolMessageTypes.reject_block_headers: RLSettings(1000, 100),
-            ProtocolMessageTypes.respond_block_headers: RLSettings(5000, 2 * 1024 * 1024),
-            ProtocolMessageTypes.request_ses_hashes: RLSettings(2000, 1 * 1024 * 1024),
-            ProtocolMessageTypes.respond_ses_hashes: RLSettings(2000, 1 * 1024 * 1024),
-            ProtocolMessageTypes.request_children: RLSettings(2000, 1024 * 1024),
-            ProtocolMessageTypes.respond_children: RLSettings(2000, 1 * 1024 * 1024),
-            ProtocolMessageTypes.request_puzzle_solution: RLSettings(5000, 100),
-            ProtocolMessageTypes.respond_puzzle_solution: RLSettings(5000, 1024 * 1024),
-            ProtocolMessageTypes.reject_puzzle_solution: RLSettings(5000, 100),
-            ProtocolMessageTypes.none_response: RLSettings(500, 100),
-            ProtocolMessageTypes.error: RLSettings(50000, 100),
-        },
-        "rate_limits_other": {  # These will have a lower cap since they don't scale with high TPS (NON_TX_FREQ)
-            ProtocolMessageTypes.request_header_blocks: RLSettings(5000, 100),
-        },
+        ProtocolMessageTypes.request_block_header: RLSettings(False, 500, 100),
+        ProtocolMessageTypes.respond_block_header: RLSettings(False, 500, 500 * 1024),
+        ProtocolMessageTypes.reject_header_request: RLSettings(False, 500, 100),
+        ProtocolMessageTypes.request_removals: RLSettings(False, 5000, 50 * 1024, 10 * 1024 * 1024),
+        ProtocolMessageTypes.respond_removals: RLSettings(False, 5000, 1024 * 1024, 10 * 1024 * 1024),
+        ProtocolMessageTypes.reject_removals_request: RLSettings(False, 500, 100),
+        ProtocolMessageTypes.request_additions: RLSettings(False, 50000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.respond_additions: RLSettings(False, 50000, 100 * 1024 * 1024),
+        ProtocolMessageTypes.reject_additions_request: RLSettings(False, 500, 100),
+        ProtocolMessageTypes.reject_header_blocks: RLSettings(False, 1000, 100),
+        ProtocolMessageTypes.respond_header_blocks: RLSettings(False, 5000, 2 * 1024 * 1024),
+        ProtocolMessageTypes.request_ses_hashes: RLSettings(False, 2000, 1 * 1024 * 1024),
+        ProtocolMessageTypes.respond_ses_hashes: RLSettings(False, 2000, 1 * 1024 * 1024),
+        ProtocolMessageTypes.request_children: RLSettings(False, 2000, 1024 * 1024),
+        ProtocolMessageTypes.respond_children: RLSettings(False, 2000, 1 * 1024 * 1024),
+        ProtocolMessageTypes.request_puzzle_solution: RLSettings(False, 5000, 100),
+        ProtocolMessageTypes.respond_puzzle_solution: RLSettings(False, 5000, 1024 * 1024),
+        ProtocolMessageTypes.reject_puzzle_solution: RLSettings(False, 5000, 100),
+        # These will have a lower cap since they don't scale with high TPS (NON_TX_FREQ)
+        ProtocolMessageTypes.request_header_blocks: RLSettings(True, 5000, 100),
     },
 }