chia-blockchain 2.4.4__py3-none-any.whl

chia/full_node/pending_tx_cache.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+from sortedcontainers import SortedDict
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.mempool_item import MempoolItem
+from chia.util.ints import uint32
+
+
+@dataclass
+class ConflictTxCache:
+    _cache_max_total_cost: int
+    _cache_max_size: int = 1000
+    _cache_cost: int = field(default=0, init=False)
+    _txs: Dict[bytes32, MempoolItem] = field(default_factory=dict, init=False)
+
+    def get(self, bundle_name: bytes32) -> Optional[MempoolItem]:
+        return self._txs.get(bundle_name, None)
+
+    def add(self, item: MempoolItem) -> None:
+        """
+        Adds SpendBundles that have failed to be added to the pool in potential tx set.
+        This is later used to retry to add them.
+        """
+        name = item.name
+
+        if name in self._txs:
+            return None
+
+        self._txs[name] = item
+        self._cache_cost += item.cost
+
+        while self._cache_cost > self._cache_max_total_cost or len(self._txs) > self._cache_max_size:
+            first_in = list(self._txs.keys())[0]
+            self._cache_cost -= self._txs[first_in].cost
+            self._txs.pop(first_in)
+
+    def drain(self) -> Dict[bytes32, MempoolItem]:
+        ret = self._txs
+        self._txs = {}
+        self._cache_cost = 0
+        return ret
+
+    def cost(self) -> int:
+        return self._cache_cost
+
+
+@dataclass
+class PendingTxCache:
+    _cache_max_total_cost: int
+    _cache_max_size: int = 3000
+    _cache_cost: int = field(default=0, init=False)
+    _txs: Dict[bytes32, MempoolItem] = field(default_factory=dict, init=False)
+    _by_height: SortedDict[uint32, Dict[bytes32, MempoolItem]] = field(default_factory=SortedDict, init=False)
+
+    def get(self, bundle_name: bytes32) -> Optional[MempoolItem]:
+        return self._txs.get(bundle_name, None)
+
+    def add(self, item: MempoolItem) -> None:
+        """
+        Adds SpendBundles that are not yet valid because of a height assertion.
+        They will be re-tried once their height requirement is satisfied
+        """
+        assert item.assert_height is not None
+
+        name = item.name
+
+        if name in self._txs:
+            return None
+
+        self._txs[name] = item
+        self._cache_cost += item.cost
+        self._by_height.setdefault(item.assert_height, {})[name] = item
+
+        while self._cache_cost > self._cache_max_total_cost or len(self._txs) > self._cache_max_size:
+            # we start removing items with the highest assert_height first
+            to_evict = self._by_height.items()[-1]
+            if to_evict[1] == {}:
+                self._txs.pop(to_evict[0])
+                continue
+
+            first_in = list(to_evict[1].keys())[0]
+            removed_item = self._txs.pop(first_in)
+            self._cache_cost -= removed_item.cost
+            to_evict[1].pop(first_in)
+            if to_evict[1] == {}:
+                self._by_height.popitem()
+
+    def drain(self, up_to_height: uint32) -> Dict[bytes32, MempoolItem]:
+        ret: Dict[bytes32, MempoolItem] = {}
+
+        if self._txs == {}:
+            return ret
+
+        height_line = self._by_height.items()[0]
+        while height_line[0] < up_to_height:
+            ret.update(height_line[1])
+            for name, item in height_line[1].items():
+                self._cache_cost -= item.cost
+                self._txs.pop(name)
+            self._by_height.popitem(0)
+            if len(self._by_height) == 0:
+                break
+            height_line = self._by_height.items()[0]
+
+        return ret
+
+    def cost(self) -> int:
+        return self._cache_cost

chia/full_node/puzzles/block_program_zero.clsp

@@ -0,0 +1,14 @@
+
+; TODO convert generators arg to list of generators
+
+(mod (decompress_puzzle decompress_coin_spend_entry start end compressed_cses deserialize gen_list reserved_arg)
+
+  (defun decompress_cses (decompress_puzzle decompress_coin_spend_entry cses deserialize puzzle_prefix)
+    (if cses
+        (c (a decompress_coin_spend_entry (list deserialize decompress_puzzle puzzle_prefix (f cses)))
+        (decompress_cses decompress_puzzle decompress_coin_spend_entry (r cses) deserialize puzzle_prefix ))
+  ()) )
+
+  (list (decompress_cses decompress_puzzle decompress_coin_spend_entry compressed_cses deserialize (substr (f gen_list) start end)))
+
+)

chia/full_node/puzzles/block_program_zero.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff02ff02ffff04ff02ffff04ff05ffff04ff0bffff04ff5fffff04ff81bfffff04ffff0cff82027fff17ff2f80ff8080808080808080ff8080ffff04ffff01ff02ffff03ff17ffff01ff04ffff02ff0bffff04ff2fffff04ff05ffff04ff5fffff04ff27ff808080808080ffff02ff02ffff04ff02ffff04ff05ffff04ff0bffff04ff37ffff04ff2fffff04ff5fff808080808080808080ff8080ff0180ff018080

chia/full_node/puzzles/decompress_coin_spend_entry.clsp

@@ -0,0 +1,5 @@
+(mod (deserialize decompress_puzzle puzzle_prefix suffix cse)
+
+  ; decompress a single compressed standard transaction
+  (c (f cse) (c (a decompress_puzzle (list deserialize puzzle_prefix (f (f (r cse))) suffix)) (c (f (r (f cse))) (r (f (r cse))))))
+)

chia/full_node/puzzles/decompress_coin_spend_entry.clsp.hex

@@ -0,0 +1 @@
+ff04ff4fffff04ffff02ff05ffff04ff02ffff04ff0bffff04ff82012fffff04ff17ff808080808080ffff04ff82014fff8201af808080

chia/full_node/puzzles/decompress_coin_spend_entry_with_prefix.clsp

@@ -0,0 +1,7 @@
+(mod (deserialize decompress_puzzle puzzle_prefix cse)
+
+  ; decompress a single compressed standard transaction
+
+  (c (f (f cse)) (c (a decompress_puzzle (list deserialize puzzle_prefix (f (f (r cse))) (q . 0xff018080))) (c (f (r (f cse))) (r (f (r cse))))))
+
+)

chia/full_node/puzzles/decompress_coin_spend_entry_with_prefix.clsp.hex

@@ -0,0 +1 @@
+ff04ff47ffff04ffff02ff05ffff04ff02ffff04ff0bffff04ff8197ffff01ff84ff0180808080808080ffff04ff81a7ff81d7808080

chia/full_node/puzzles/decompress_puzzle.clsp

@@ -0,0 +1,6 @@
+(mod (deserialize puzzle_prefix pubkey suffix)
+
+  (a deserialize (list (concat puzzle_prefix pubkey suffix)))
+
+)
+

chia/full_node/puzzles/decompress_puzzle.clsp.hex

@@ -0,0 +1 @@
+ff02ff02ffff04ffff0eff05ff0bff1780ff808080

chia/full_node/signage_point.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
+from chia.util.streamable import Streamable, streamable
+
+
+@streamable
+@dataclass(frozen=True)
+class SignagePoint(Streamable):
+    cc_vdf: Optional[VDFInfo]
+    cc_proof: Optional[VDFProof]
+    rc_vdf: Optional[VDFInfo]
+    rc_proof: Optional[VDFProof]

chia/full_node/subscriptions.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Dict, List, Set
+
+from chia_rs import Coin
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.spend_bundle_conditions import SpendBundleConditions
+from chia.util.ints import uint64
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class SubscriptionSet:
+    _subscriptions_for_peer: Dict[bytes32, Set[bytes32]] = field(default_factory=dict, init=False)
+    _peers_for_subscription: Dict[bytes32, Set[bytes32]] = field(default_factory=dict, init=False)
+
+    def add_subscription(self, peer_id: bytes32, item: bytes32) -> bool:
+        peers = self._peers_for_subscription.setdefault(item, set())
+
+        if peer_id in peers:
+            return False
+
+        subscriptions = self._subscriptions_for_peer.setdefault(peer_id, set())
+        subscriptions.add(item)
+        peers.add(peer_id)
+
+        return True
+
+    def remove_subscription(self, peer_id: bytes32, item: bytes32) -> bool:
+        subscriptions = self._subscriptions_for_peer.get(peer_id)
+
+        if subscriptions is None or item not in subscriptions:
+            return False
+
+        peers = self._peers_for_subscription[item]
+        peers.remove(peer_id)
+        subscriptions.remove(item)
+
+        if len(subscriptions) == 0:
+            self._subscriptions_for_peer.pop(peer_id)
+
+        if len(peers) == 0:
+            self._peers_for_subscription.pop(item)
+
+        return True
+
+    def has_subscription(self, item: bytes32) -> bool:
+        return item in self._peers_for_subscription
+
+    def count_subscriptions(self, peer_id: bytes32) -> int:
+        return len(self._subscriptions_for_peer.get(peer_id, {}))
+
+    def remove_peer(self, peer_id: bytes32) -> None:
+        for item in self._subscriptions_for_peer.pop(peer_id, {}):
+            self._peers_for_subscription[item].remove(peer_id)
+
+            if len(self._peers_for_subscription[item]) == 0:
+                self._peers_for_subscription.pop(item)
+
+    def subscriptions(self, peer_id: bytes32) -> Set[bytes32]:
+        return self._subscriptions_for_peer.get(peer_id, set())
+
+    def peers(self, item: bytes32) -> Set[bytes32]:
+        return self._peers_for_subscription.get(item, set())
+
+    def total_count(self) -> int:
+        return len(self._peers_for_subscription)
+
+
+@dataclass(frozen=True)
+class PeerSubscriptions:
+    _puzzle_subscriptions: SubscriptionSet = field(default_factory=SubscriptionSet)
+    _coin_subscriptions: SubscriptionSet = field(default_factory=SubscriptionSet)
+
+    def has_puzzle_subscription(self, puzzle_hash: bytes32) -> bool:
+        return self._puzzle_subscriptions.has_subscription(puzzle_hash)
+
+    def has_coin_subscription(self, coin_id: bytes32) -> bool:
+        return self._coin_subscriptions.has_subscription(coin_id)
+
+    def peer_subscription_count(self, peer_id: bytes32) -> int:
+        puzzle_subscriptions = self._puzzle_subscriptions.count_subscriptions(peer_id)
+        coin_subscriptions = self._coin_subscriptions.count_subscriptions(peer_id)
+        return puzzle_subscriptions + coin_subscriptions
+
+    def add_puzzle_subscriptions(self, peer_id: bytes32, puzzle_hashes: List[bytes32], max_items: int) -> Set[bytes32]:
+        """
+        Adds subscriptions until max_items is reached. Filters out duplicates and returns all additions.
+        """
+
+        subscription_count = self.peer_subscription_count(peer_id)
+        added: Set[bytes32] = set()
+
+        def limit_reached() -> Set[bytes32]:
+            log.info(
+                "Peer %s attempted to exceed the subscription limit while adding puzzle subscriptions.",
+                peer_id,
+            )
+            return added
+
+        # If the subscription limit is reached, bail.
+        if subscription_count >= max_items:
+            return limit_reached()
+
+        # Decrement this counter to know if we've hit the subscription limit.
+        subscriptions_left = max_items - subscription_count
+
+        for puzzle_hash in puzzle_hashes:
+            if not self._puzzle_subscriptions.add_subscription(peer_id, puzzle_hash):
+                continue
+
+            subscriptions_left -= 1
+            added.add(puzzle_hash)
+
+            if subscriptions_left == 0:
+                return limit_reached()
+
+        return added
+
+    def add_coin_subscriptions(self, peer_id: bytes32, coin_ids: List[bytes32], max_items: int) -> Set[bytes32]:
+        """
+        Adds subscriptions until max_items is reached. Filters out duplicates and returns all additions.
+        """
+
+        subscription_count = self.peer_subscription_count(peer_id)
+        added: Set[bytes32] = set()
+
+        def limit_reached() -> Set[bytes32]:
+            log.info(
+                "Peer %s attempted to exceed the subscription limit while adding coin subscriptions.",
+                peer_id,
+            )
+            return added
+
+        # If the subscription limit is reached, bail.
+        if subscription_count >= max_items:
+            return limit_reached()
+
+        # Decrement this counter to know if we've hit the subscription limit.
+        subscriptions_left = max_items - subscription_count
+
+        for coin_id in coin_ids:
+            if not self._coin_subscriptions.add_subscription(peer_id, coin_id):
+                continue
+
+            subscriptions_left -= 1
+            added.add(coin_id)
+
+            if subscriptions_left == 0:
+                return limit_reached()
+
+        return added
+
+    def remove_puzzle_subscriptions(self, peer_id: bytes32, puzzle_hashes: List[bytes32]) -> Set[bytes32]:
+        """
+        Removes subscriptions. Filters out duplicates and returns all removals.
+        """
+
+        removed: Set[bytes32] = set()
+
+        for puzzle_hash in puzzle_hashes:
+            if not self._puzzle_subscriptions.remove_subscription(peer_id, puzzle_hash):
+                continue
+
+            removed.add(puzzle_hash)
+
+        return removed
+
+    def remove_coin_subscriptions(self, peer_id: bytes32, coin_ids: List[bytes32]) -> Set[bytes32]:
+        """
+        Removes subscriptions. Filters out duplicates and returns all removals.
+        """
+
+        removed: Set[bytes32] = set()
+
+        for coin_id in coin_ids:
+            if not self._coin_subscriptions.remove_subscription(peer_id, coin_id):
+                continue
+
+            removed.add(coin_id)
+
+        return removed
+
+    def clear_puzzle_subscriptions(self, peer_id: bytes32) -> None:
+        self._puzzle_subscriptions.remove_peer(peer_id)
+
+    def clear_coin_subscriptions(self, peer_id: bytes32) -> None:
+        self._coin_subscriptions.remove_peer(peer_id)
+
+    def remove_peer(self, peer_id: bytes32) -> None:
+        self._puzzle_subscriptions.remove_peer(peer_id)
+        self._coin_subscriptions.remove_peer(peer_id)
+
+    def coin_subscriptions(self, peer_id: bytes32) -> Set[bytes32]:
+        return self._coin_subscriptions.subscriptions(peer_id)
+
+    def puzzle_subscriptions(self, peer_id: bytes32) -> Set[bytes32]:
+        return self._puzzle_subscriptions.subscriptions(peer_id)
+
+    def peers_for_coin_id(self, coin_id: bytes32) -> Set[bytes32]:
+        return self._coin_subscriptions.peers(coin_id)
+
+    def peers_for_puzzle_hash(self, puzzle_hash: bytes32) -> Set[bytes32]:
+        return self._puzzle_subscriptions.peers(puzzle_hash)
+
+    def coin_subscription_count(self) -> int:
+        return self._coin_subscriptions.total_count()
+
+    def puzzle_subscription_count(self) -> int:
+        return self._puzzle_subscriptions.total_count()
+
+
+def peers_for_spend_bundle(
+    peer_subscriptions: PeerSubscriptions, conds: SpendBundleConditions, hints_for_removals: Set[bytes32]
+) -> Set[bytes32]:
+    """
+    Returns a list of peer ids that are subscribed to any of the created or
+    spent coins, puzzle hashes, or hints in the spend bundle. To avoid repeated
+    lookups, `hints_for_removals` should be a set of all puzzle hashes that are being removed.
+    """
+
+    coin_ids: Set[bytes32] = set()
+    puzzle_hashes: Set[bytes32] = hints_for_removals.copy()
+
+    for spend in conds.spends:
+        coin_ids.add(bytes32(spend.coin_id))
+        puzzle_hashes.add(bytes32(spend.puzzle_hash))
+
+        for puzzle_hash, amount, memo in spend.create_coin:
+            coin_ids.add(Coin(spend.coin_id, puzzle_hash, uint64(amount)).name())
+            puzzle_hashes.add(bytes32(puzzle_hash))
+
+            if memo is not None and len(memo) == 32:
+                puzzle_hashes.add(bytes32(memo))
+
+    peers: Set[bytes32] = set()
+
+    for coin_id in coin_ids:
+        peers |= peer_subscriptions.peers_for_coin_id(coin_id)
+
+    for puzzle_hash in puzzle_hashes:
+        peers |= peer_subscriptions.peers_for_puzzle_hash(puzzle_hash)
+
+    return peers

chia/full_node/sync_store.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import asyncio
+import collections
+import logging
+from collections import OrderedDict as orderedDict
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, OrderedDict, Set
+
+import typing_extensions
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint32, uint128
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class Peak:
+    header_hash: bytes32
+    height: uint32
+    weight: uint128
+
+
+@typing_extensions.final
+@dataclass
+class SyncStore:
+    # Whether or not we are syncing
+    sync_mode: bool = False
+    long_sync: bool = False
+    # Header hash : peer node id
+    peak_to_peer: OrderedDict[bytes32, Set[bytes32]] = field(default_factory=orderedDict)
+    # peer node id : Peak
+    peer_to_peak: Dict[bytes32, Peak] = field(default_factory=dict)
+    # Peak we are syncing towards
+    target_peak: Optional[Peak] = None
+    peers_changed: asyncio.Event = field(default_factory=asyncio.Event)
+    # Set of nodes which we are batch syncing from
+    batch_syncing: Set[bytes32] = field(default_factory=set)
+    # Set of nodes which we are backtrack syncing from, and how many threads
+    _backtrack_syncing: collections.defaultdict[bytes32, int] = field(
+        default_factory=lambda: collections.defaultdict(int),
+    )
+
+    def set_sync_mode(self, sync_mode: bool) -> None:
+        self.sync_mode = sync_mode
+
+    def get_sync_mode(self) -> bool:
+        return self.sync_mode
+
+    def set_long_sync(self, long_sync: bool) -> None:
+        self.long_sync = long_sync
+
+    def get_long_sync(self) -> bool:
+        return self.long_sync
+
+    def seen_header_hash(self, header_hash: bytes32) -> bool:
+        return header_hash in self.peak_to_peer
+
+    def peer_has_block(
+        self, header_hash: bytes32, peer_id: bytes32, weight: uint128, height: uint32, new_peak: bool
+    ) -> None:
+        """
+        Adds a record that a certain peer has a block.
+        """
+
+        if self.target_peak is not None and header_hash == self.target_peak.header_hash:
+            self.peers_changed.set()
+        if header_hash in self.peak_to_peer:
+            self.peak_to_peer[header_hash].add(peer_id)
+        else:
+            self.peak_to_peer[header_hash] = {peer_id}
+            if len(self.peak_to_peer) > 256:  # nice power of two
+                item = self.peak_to_peer.popitem(last=False)  # Remove the oldest entry
+                # sync target hash is used throughout the sync process and should not be deleted.
+                if self.target_peak is not None and item[0] == self.target_peak.header_hash:
+                    self.peak_to_peer[item[0]] = item[1]  # Put it back in if it was the sync target
+                    self.peak_to_peer.popitem(last=False)  # Remove the oldest entry again
+        if new_peak:
+            self.peer_to_peak[peer_id] = Peak(header_hash, height, weight)
+
+    def get_peers_that_have_peak(self, header_hashes: List[bytes32]) -> Set[bytes32]:
+        """
+        Returns: peer ids of peers that have at least one of the header hashes.
+        """
+
+        node_ids: Set[bytes32] = set()
+        for header_hash in header_hashes:
+            if header_hash in self.peak_to_peer:
+                for node_id in self.peak_to_peer[header_hash]:
+                    node_ids.add(node_id)
+        return node_ids
+
+    def get_peak_of_each_peer(self) -> Dict[bytes32, Peak]:
+        """
+        Returns: dictionary of peer id to peak information.
+        """
+
+        ret = {}
+        for peer_id, peak in self.peer_to_peak.items():
+            if peak.header_hash not in self.peak_to_peer:
+                continue
+            ret[peer_id] = peak
+        return ret
+
+    def get_heaviest_peak(self) -> Optional[Peak]:
+        """
+        Returns: the header_hash, height, and weight of the heaviest block that one of our peers has notified
+        us of.
+        """
+
+        if len(self.peer_to_peak) == 0:
+            return None
+        heaviest_peak: Optional[Peak] = None
+        for peak in self.peer_to_peak.values():
+            if peak.header_hash not in self.peak_to_peer:
+                continue
+            if heaviest_peak is None or peak.weight > heaviest_peak.weight:
+                heaviest_peak = peak
+        assert heaviest_peak is not None
+        return heaviest_peak
+
+    def peer_disconnected(self, node_id: bytes32) -> None:
+        if node_id in self.peer_to_peak:
+            del self.peer_to_peak[node_id]
+
+        for peak, peers in self.peak_to_peer.items():
+            if node_id in peers:
+                self.peak_to_peer[peak].remove(node_id)
+            assert node_id not in self.peak_to_peer[peak]
+
+        self._backtrack_syncing.pop(node_id, None)
+
+        self.peers_changed.set()
+
+    def is_backtrack_syncing(self, node_id: bytes32) -> bool:
+        return self._backtrack_syncing.get(node_id, 0) > 0
+
+    def increment_backtrack_syncing(self, node_id: bytes32) -> None:
+        self._backtrack_syncing[node_id] += 1
+
+    def decrement_backtrack_syncing(self, node_id: bytes32) -> None:
+        self._backtrack_syncing[node_id] -= 1
+        if self._backtrack_syncing[node_id] < 1:
+            del self._backtrack_syncing[node_id]

chia/full_node/tx_processing_queue.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from queue import SimpleQueue
+from typing import Dict, List, Optional
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.transaction_queue_entry import TransactionQueueEntry
+
+
+class TransactionQueueFull(Exception):
+    pass
+
+
+@dataclass
+class TransactionQueue:
+    """
+    This class replaces one queue by using a high priority queue for local transactions and separate queues for peers.
+    Local transactions are processed first.
+    Then the next transaction is taken from the next non-empty queue after the last processed queue. (round-robin)
+    This decreases the effects of one peer spamming your node with transactions.
+    """
+
+    _list_cursor: int  # this is which index
+    _queue_length: asyncio.Semaphore
+    _index_to_peer_map: List[bytes32]
+    _queue_dict: Dict[bytes32, SimpleQueue[TransactionQueueEntry]]
+    _high_priority_queue: SimpleQueue[TransactionQueueEntry]
+    peer_size_limit: int
+    log: logging.Logger
+
+    def __init__(self, peer_size_limit: int, log: logging.Logger) -> None:
+        self._list_cursor = 0
+        self._queue_length = asyncio.Semaphore(0)  # default is 1
+        self._index_to_peer_map = []
+        self._queue_dict = {}
+        self._high_priority_queue = SimpleQueue()  # we don't limit the number of high priority transactions
+        self.peer_size_limit = peer_size_limit
+        self.log = log
+
+    async def put(self, tx: TransactionQueueEntry, peer_id: Optional[bytes32], high_priority: bool = False) -> None:
+        if peer_id is None or high_priority:  # when it's local there is no peer_id.
+            self._high_priority_queue.put(tx)
+        else:
+            if peer_id not in self._queue_dict:
+                self._queue_dict[peer_id] = SimpleQueue()
+                self._index_to_peer_map.append(peer_id)
+            if self._queue_dict[peer_id].qsize() < self.peer_size_limit:
+                self._queue_dict[peer_id].put(tx)
+            else:
+                self.log.warning(f"Transaction queue full for peer {peer_id}")
+                raise TransactionQueueFull(f"Transaction queue full for peer {peer_id}")
+        self._queue_length.release()  # increment semaphore to indicate that we have a new item in the queue
+
+    async def pop(self) -> TransactionQueueEntry:
+        await self._queue_length.acquire()
+        if not self._high_priority_queue.empty():
+            return self._high_priority_queue.get()
+        result: Optional[TransactionQueueEntry] = None
+        while True:
+            peer_queue = self._queue_dict[self._index_to_peer_map[self._list_cursor]]
+            if not peer_queue.empty():
+                result = peer_queue.get()
+            self._list_cursor += 1
+            if self._list_cursor > len(self._index_to_peer_map) - 1:
+                # reset iterator
+                self._list_cursor = 0
+                new_peer_map = []
+                for peer_id in self._index_to_peer_map:
+                    if self._queue_dict[peer_id].empty():
+                        self._queue_dict.pop(peer_id)
+                    else:
+                        new_peer_map.append(peer_id)
+                self._index_to_peer_map = new_peer_map
+            if result is not None:
+                return result