605 lines
24 KiB
Python
605 lines
24 KiB
Python
# The Carnot protocol is designed to be elastic, responsive, and provide fast finality
|
|
# Elastic scalability allows the protocol to operate effectively with both small and large networks
|
|
# All nodes in the Carnot network participate in the consensus of a block
|
|
# Optimistic responsiveness enables the protocol to operate quickly during periods of synchrony and honest leadership
|
|
# There is no block generation time in Carnot, allowing for fast finality
|
|
# Carnot avoids the chain reorg problem, making it compatible with PoS schemes
|
|
# This enhances the robustness of the protocol, making it a valuable addition to the ecosystem of consensus protocols
|
|
|
|
|
|
# The protocol in Carnot operates in two modes: the happy path and the unhappy path.
|
|
#
|
|
# In Carnot, nodes are arranged in a binary tree overlay committee structure. Moreover, Carnot is a
|
|
# pipelined consensus protocol where a block contains the proof of attestation of its parent. In happy path the
|
|
# leader proposes a block that contains a quorum certificate (QC) with votes from more than two-thirds of the root
|
|
# committee and its child committee/ committees. The voting process begins at the leaf committee where nodes verify
|
|
# the proposal and send their votes to the parent committee. Once a node in the parent committee receives more than
|
|
# two-thirds of the votes from its child committee members, it sends its votes to its parent. This process continues
|
|
# recursively until the root committee members collect votes from its child committee/ committees. The root committee
|
|
# member builds a QC from the votes and sends it to the next leader. The leader builds a QC and proposes the next block
|
|
# upon receiving more than two-thirds of votes.
|
|
|
|
|
|
# In the unhappy path, if a node does not receive a message within a timeout interval, it will timeout. Only nodes at
|
|
# the root committee and its child committee/ committees send their timeout messages to the root committee. The root
|
|
# committee builds a timeout QC from more than two-thirds of messages, recalculates the new overlay, and broadcasts it
|
|
# to the network. Similar to the happy path, the timeout message moves from leaves to the root. Each parent waits for
|
|
# more than two-thirds of timeout messages from its child committees and sends its timeout to the parent committee once
|
|
# the threshold is reached. A node in the root committee builds a QC from timeout messages received from its
|
|
# child committee/committees and forwards it to the next leader. Upon receiving more than two-thirds of timeout
|
|
# messages, the next leader builds an aggregated QC and proposes the next block containing the aggregated QC.
|
|
# It should be noted that while receiving timeout messages, each node also updates its high_qc (the most recent QC)
|
|
# and passes it to its parent through the timeout message. In this way, the aggregated QC will include the high_qc seen
|
|
# by the majority of honest nodes. Hence, after the view change, the protocol safety is preserved.
|
|
|
|
|
|
# Please note this is still a work in progress
|
|
|
|
from dataclasses import dataclass
|
|
from typing import TypeAlias, List, Set, Self, Optional, Dict
|
|
from abc import abstractmethod, ABC
|
|
|
|
Id: TypeAlias = bytes
|
|
View: TypeAlias = int
|
|
Committee: TypeAlias = Set[Id]
|
|
|
|
|
|
def int_to_id(i: int) -> Id:
|
|
return bytes(str(i), encoding="utf8")
|
|
|
|
|
|
@dataclass(unsafe_hash=True)
|
|
class StandardQc:
|
|
block: Id
|
|
view: View
|
|
|
|
def view(self) -> View:
|
|
return self.view
|
|
|
|
|
|
@dataclass
|
|
class AggregateQc:
|
|
qcs: List[View]
|
|
highest_qc: StandardQc
|
|
view: View
|
|
|
|
def view(self) -> View:
|
|
return self.view
|
|
|
|
def high_qc(self) -> StandardQc:
|
|
assert self.highest_qc.view == max(self.qcs)
|
|
return self.highest_qc
|
|
|
|
|
|
Qc: TypeAlias = StandardQc | AggregateQc
|
|
|
|
|
|
@dataclass
|
|
class Block:
|
|
view: View
|
|
qc: Qc
|
|
_id: Id # this is an abstration over the block id, which should be the hash of the contents
|
|
|
|
def extends(self, ancestor: Self) -> bool:
|
|
"""
|
|
:param ancestor:
|
|
:return: true if block is descendant of the ancestor in the chain
|
|
"""
|
|
return self.view > ancestor.view
|
|
|
|
def parent(self) -> Id:
|
|
match self.qc:
|
|
case StandardQc(block):
|
|
return block
|
|
case AggregateQc() as aqc:
|
|
return aqc.high_qc().block
|
|
|
|
def id(self) -> Id:
|
|
return self._id
|
|
|
|
|
|
@dataclass(unsafe_hash=True)
|
|
class Vote:
|
|
block: Id
|
|
view: View
|
|
voter: Id
|
|
qc: Optional[Qc]
|
|
|
|
|
|
@dataclass
|
|
class TimeoutQc:
|
|
view: View
|
|
high_qc: Qc
|
|
qc_views: List[View]
|
|
sender_ids: Set[Id]
|
|
sender: Id
|
|
|
|
|
|
@dataclass
|
|
class Timeout:
|
|
"""
|
|
Local timeout field is only used by the root committee and its children when they timeout. The timeout_qc is built
|
|
from local_timeouts. Leaf nodes when receive timeout_qc build their timeout msg and includes the timeout_qc in it.
|
|
The timeout_qc is indicator that the root committee and its child committees (if exist) have failed to collect votes.
|
|
"""
|
|
view: View
|
|
high_qc: Qc
|
|
sender: Id
|
|
timeout_qc: TimeoutQc
|
|
|
|
|
|
# Timeout has been detected, nodes agree on it and gather high qc
|
|
@dataclass
|
|
class NewView:
|
|
view: View
|
|
high_qc: Qc
|
|
sender: Id
|
|
timeout_qc: TimeoutQc
|
|
|
|
|
|
Quorum: TypeAlias = Set[Vote] | Set[NewView]
|
|
|
|
|
|
Payload: TypeAlias = Block | Vote | Timeout | NewView | TimeoutQc
|
|
|
|
@dataclass
|
|
class BroadCast:
|
|
payload: Payload
|
|
|
|
|
|
@dataclass
|
|
class Send:
|
|
to: [Id]
|
|
payload: Payload
|
|
|
|
|
|
Event: TypeAlias = BroadCast | Send
|
|
|
|
|
|
class Overlay:
|
|
"""
|
|
Overlay structure for a View
|
|
"""
|
|
|
|
@abstractmethod
|
|
def is_leader(self, _id: Id):
|
|
"""
|
|
:param _id: Node id to be checked
|
|
:return: true if node is the leader of the current view
|
|
"""
|
|
return _id == self.leader()
|
|
|
|
@abstractmethod
|
|
def leader(self) -> Id:
|
|
"""
|
|
:param view:
|
|
:return: the leader Id of the specified view
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def next_leader(self) -> Id:
|
|
pass
|
|
|
|
@abstractmethod
|
|
def is_member_of_leaf_committee(self, _id: Id) -> bool:
|
|
"""
|
|
:param _id: Node id to be checked
|
|
:return: true if the participant with Id _id is in the leaf committee of the committee overlay
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def is_member_of_root_committee(self, _id: Id) -> bool:
|
|
"""
|
|
:param _id:
|
|
:return: true if the participant with Id _id is member of the root committee withing the tree overlay
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def is_member_of_child_committee(self, parent: Id, child: Id) -> bool:
|
|
"""
|
|
:param parent:
|
|
:param child:
|
|
:return: true if participant with Id child is member of the child committee of the participant with Id parent
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def parent_committee(self, _id: Id) -> Optional[Committee]:
|
|
"""
|
|
:param _id:
|
|
:return: Some(parent committee) of the participant with Id _id withing the committee tree overlay
|
|
or Empty if the member with Id _id is a participant of the root committee
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def leaf_committees(self) -> Set[Committee]:
|
|
pass
|
|
|
|
@abstractmethod
|
|
def root_committee(self) -> Committee:
|
|
"""
|
|
:return: returns root committee
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def is_child_of_root_committee(self, _id: Id) -> bool:
|
|
"""
|
|
:return: returns child committee/s of root committee if present
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def leader_super_majority_threshold(self, _id: Id) -> int:
|
|
"""
|
|
Amount of distinct number of messages for a node with Id _id member of a committee
|
|
The return value may change depending on which committee the node is member of, including the leader
|
|
:return:
|
|
"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
def super_majority_threshold(self, _id: Id) -> int:
|
|
pass
|
|
|
|
|
|
def download(view) -> Block:
|
|
raise NotImplementedError
|
|
|
|
|
|
class Carnot:
|
|
def __init__(self, _id: Id, overlay=Overlay()):
|
|
self.id: Id = _id
|
|
# Current View counter
|
|
# It is the view currently being processed by the node. Once a Qc is received, the view is considered completed
|
|
# and the current view is updated to qc.view+1
|
|
self.current_view: View = 0
|
|
# Highest voted view counter. This is used to prevent a node from voting twice or vote after timeout.
|
|
self.highest_voted_view: View = -1
|
|
# This is most recent (in terms of view) Standard QC that has been received by the node
|
|
self.local_high_qc: Optional[Qc] = None
|
|
# Validated blocks with their validated QCs are included here. If commit conditions are satisfied for
|
|
# each one of these blocks it will be committed.
|
|
self.safe_blocks: Dict[Id, Block] = dict()
|
|
# Whether the node time out in the last view and corresponding qc
|
|
self.last_view_timeout_qc: Optional[TimeoutQc] = None
|
|
self.overlay: Overlay = overlay
|
|
|
|
|
|
# Committing conditions for a block
|
|
# TODO: explain the conditions in comment
|
|
def can_commit_grandparent(self, block) -> bool:
|
|
parent = self.safe_blocks.get(block.parent())
|
|
grand_parent = self.safe_blocks.get(parent.parent())
|
|
# this case should just trigger on genesis_case,
|
|
# as the preconditions on outer calls should check on block validity
|
|
if not parent or not grand_parent:
|
|
return False
|
|
return (
|
|
parent.view == (grand_parent.view + 1) and
|
|
isinstance(block.qc, (StandardQc,)) and
|
|
isinstance(parent.qc, (StandardQc,))
|
|
)
|
|
|
|
|
|
# The latest committed view is implicit in the safe blocks tree given
|
|
# the committing conditions.
|
|
# For convenience, this is an helper method to retrieve that value.
|
|
def latest_committed_view(self) -> View:
|
|
return self.latest_committed_block().view
|
|
|
|
# Return the list of blocks received by a node for a specific view.
|
|
# It will return more than one block only in case of a malicious leader
|
|
def blocks_in_view(self, view: View) -> List[Block]:
|
|
return [block for block in self.safe_blocks.values() if block.view == view]
|
|
|
|
def genesis_block(self) -> Block:
|
|
return self.blocks_in_view(0)[0]
|
|
|
|
def latest_committed_block(self) -> Block:
|
|
for view in range(self.current_view, 0, -1):
|
|
for block in self.blocks_in_view(view):
|
|
if self.can_commit_grandparent(block):
|
|
return self.safe_blocks.get(self.safe_blocks.get(block.parent()).parent())
|
|
# genesis blocks is always considered committed
|
|
return self.genesis_block()
|
|
|
|
# Given committing conditions, the set of committed blocks is implicit
|
|
# in the safe blocks tree. For convenience, this is an helper method to
|
|
# retrieve that set.
|
|
def committed_blocks(self) -> Dict[Id, Block]:
|
|
tip = self.latest_committed_block()
|
|
committed_blocks = {tip.id(): tip, self.genesis_block().id: self.genesis_block()}
|
|
while tip.view > 0:
|
|
committed_blocks[tip.id()] = tip
|
|
tip = self.safe_blocks.get(tip.parent())
|
|
return committed_blocks
|
|
|
|
def block_is_safe(self, block: Block) -> bool:
|
|
return (
|
|
block.view >= self.current_view and
|
|
block.view == block.qc.view + 1
|
|
)
|
|
|
|
# Ask Dani
|
|
def update_high_qc(self, qc: Qc):
|
|
match (self.local_high_qc, qc):
|
|
case (None, StandardQc() as new_qc):
|
|
self.local_high_qc = new_qc
|
|
case (None, AggregateQc() as new_qc):
|
|
self.local_high_qc = new_qc.high_qc()
|
|
case (old_qc, StandardQc() as new_qc) if new_qc.view > old_qc.view:
|
|
self.local_high_qc = new_qc
|
|
case (old_qc, AggregateQc() as new_qc) if new_qc.high_qc().view != old_qc.view:
|
|
self.local_high_qc = new_qc.high_qc()
|
|
# if my view is not updated I update it when I see a qc for that view
|
|
if qc.view == self.current_view:
|
|
self.current_view = self.current_view + 1
|
|
|
|
def update_timeout_qc(self, timeout_qc: TimeoutQc):
|
|
match (self.last_view_timeout_qc, timeout_qc):
|
|
case (None, timeout_qc):
|
|
self.last_view_timeout_qc = timeout_qc
|
|
case (self.last_view_timeout_qc, timeout_qc) if timeout_qc.view > self.last_view_timeout_qc.view:
|
|
self.last_view_timeout_qc = timeout_qc
|
|
|
|
def receive_block(self, block: Block):
|
|
assert block.parent() in self.safe_blocks
|
|
|
|
if block.id() in self.safe_blocks:
|
|
return
|
|
if self.blocks_in_view(block.view) != [] or block.view <= self.latest_committed_view():
|
|
# TODO: Report malicious leader
|
|
# TODO: it could be possible that a malicious leader send a block to a node and another one to
|
|
# the rest of the network. The node should be able to catch up with the rest of the network after having
|
|
# validated that the history of the block is correct and diverged from its fork.
|
|
# By rejecting any other blocks except the first one received for a view this code does NOT do that.
|
|
return
|
|
|
|
# TODO: check the proposer of the block is indeed leader for that view
|
|
|
|
if self.block_is_safe(block):
|
|
self.safe_blocks[block.id()] = block
|
|
self.update_high_qc(block.qc)
|
|
|
|
def approve_block(self, block: Block, votes: Set[Vote]) -> Event:
|
|
assert block.id() in self.safe_blocks
|
|
assert len(votes) == self.overlay.super_majority_threshold(self.id)
|
|
assert all(self.overlay.is_member_of_child_committee(self.id, vote.voter) for vote in votes)
|
|
assert all(vote.block == block.id() for vote in votes)
|
|
assert self.highest_voted_view < block.view
|
|
|
|
if self.overlay.is_member_of_root_committee(self.id):
|
|
qc = self.build_qc(block.view, block, None)
|
|
else:
|
|
qc = None
|
|
|
|
vote: Vote = Vote(
|
|
block=block.id(),
|
|
voter=self.id,
|
|
view=block.view,
|
|
qc=qc
|
|
)
|
|
|
|
self.highest_voted_view = max(self.highest_voted_view, block.view)
|
|
|
|
if self.overlay.is_member_of_root_committee(self.id):
|
|
return Send(to=self.overlay.leader(block.view + 1), payload=vote)
|
|
return Send(to=self.overlay.parent_committee(self.id), payload=vote)
|
|
|
|
def forward_vote(self, vote: Vote) -> Optional[Event]:
|
|
"""
|
|
Recall that for the leader to propose a block it's necessary to have a threshold of the top three committees
|
|
votes. In case part of the root committee is malicious and does not vote, the leader might not reach this threshold
|
|
even though more than 2/3 of the total nodes voted in favor if nodes stop sending votes after the threshold.
|
|
By forwarding votes from children (only the root committee does this), we can improve liveness in this case.
|
|
"""
|
|
assert vote.block in self.safe_blocks
|
|
assert self.overlay.is_member_of_child_committee(self.id, vote.voter)
|
|
# we only forward votes after we've voted ourselves
|
|
assert self.highest_voted_view == vote.view
|
|
|
|
if self.overlay.is_member_of_root_committee(self.id):
|
|
return Send(to=self.overlay.next_leader(), payload=vote)
|
|
|
|
def forward_new_view(self, msg: NewView) -> Optional[Event]:
|
|
assert msg.view == self.current_view
|
|
assert self.overlay.is_member_of_child_committee(self.id, msg.sender)
|
|
# we only forward votes after we've voted ourselves
|
|
assert self.highest_voted_view == msg.view
|
|
|
|
if self.overlay.is_member_of_root_committee(self.id):
|
|
return Send(to=self.overlay.next_leader(), payload=msg)
|
|
|
|
def build_qc(self, view: View, block: Optional[Block], new_views: Optional[Set[NewView]]) -> Qc:
|
|
# unhappy path
|
|
if new_views:
|
|
new_views = list(new_views)
|
|
return AggregateQc(
|
|
qcs=[msg.high_qc.view for msg in new_views],
|
|
highest_qc=max(new_views, key=lambda x: x.high_qc.view).high_qc,
|
|
view=new_views[0].view
|
|
)
|
|
# happy path
|
|
return StandardQc(
|
|
view=view,
|
|
block=block.id()
|
|
)
|
|
|
|
def propose_block(self, view: View, quorum: Quorum) -> Event:
|
|
assert self.overlay.is_leader(self.id)
|
|
assert len(quorum) >= self.overlay.leader_super_majority_threshold(self.id)
|
|
|
|
qc = None
|
|
quorum = list(quorum)
|
|
# happy path
|
|
if isinstance(quorum[0], Vote):
|
|
vote = quorum[0]
|
|
qc = self.build_qc(vote.view, self.safe_blocks[vote.block], None)
|
|
# unhappy path
|
|
elif isinstance(quorum[0], NewView):
|
|
new_view = quorum[0]
|
|
qc = self.build_qc(new_view.view, None, quorum)
|
|
|
|
block = Block(
|
|
view=view,
|
|
qc=qc,
|
|
# Dummy id for proposing next block
|
|
_id=int_to_id(hash(
|
|
(
|
|
bytes(f"{view}".encode(encoding="utf8")),
|
|
bytes(f"{qc.view}".encode(encoding="utf8"))
|
|
)
|
|
))
|
|
)
|
|
return BroadCast(payload=block)
|
|
|
|
def is_safe_to_timeout_invariant(
|
|
self,
|
|
):
|
|
"""
|
|
Local timeout is different for the root and its child committees. If other committees timeout, they only
|
|
stop taking part in consensus. If a member of root or its child committees timeout it sends its timeout message
|
|
to all members of root to build the timeout qc. Using this qc we assume that the new
|
|
overlay can be built. Hence, by building the new overlay members of root committee can send the timeout qc
|
|
to the leaf committee of the new overlay. Upon receipt of the timeout qc the leaf committee members update
|
|
their local_high_qc, last_timeout_view_qc and last_voted_view if the view of qcs
|
|
(local_high_qc, last_timeout_view_qc) received is higher than their local view. Similarly last_voted_view is
|
|
updated if it is greater than the current last_voted_view. When parent committee member receives more than two
|
|
third of timeout messages from its children it also updates its local_high_qc, last_timeout_view_qc and
|
|
last_voted_view if needed and then send its timeout message upward. In this way the latest qcs move upward
|
|
that makes it possible for the next leader to propose a block with the latest local_high_qcs in aggregated qc
|
|
from more than two third members of root committee and its children.
|
|
"""
|
|
|
|
# Make sure the node doesn't time out continuously without finishing the step to increment the current view.
|
|
# Make sure current view is always higher than the local_high_qc so that the node won't timeout unnecessary
|
|
# for a previous view.
|
|
assert self.current_view > max(self.highest_voted_view - 1, self.local_high_qc.view)
|
|
# This condition makes sure a node waits for timeout_qc from root committee to change increment its view with
|
|
# a view change.
|
|
# A node must change its view after making sure it has the high_Qc or last_timeout_view_qc
|
|
# from previous view.
|
|
return (
|
|
self.current_view == self.local_high_qc.view + 1 or
|
|
self.current_view == self.last_view_timeout_qc.view + 1 or
|
|
(self.current_view == self.last_view_timeout_qc.view)
|
|
)
|
|
|
|
def local_timeout(self) -> Optional[Event]:
|
|
"""
|
|
Root committee changes for each failure, so repeated failure will be handled by different
|
|
root committees
|
|
"""
|
|
# avoid voting after we timeout
|
|
self.highest_voted_view = self.current_view
|
|
|
|
if self.overlay.is_member_of_root_committee(self.id) or self.overlay.is_child_of_root_committee(self.id):
|
|
timeout_msg: Timeout = Timeout(
|
|
view=self.current_view,
|
|
high_qc=self.local_high_qc,
|
|
# local_timeout is only true for the root committee or members of its children
|
|
# root committee or its children can trigger the timeout.
|
|
timeout_qc=self.last_view_timeout_qc,
|
|
sender=self.id
|
|
)
|
|
return Send(payload=timeout_msg, to=self.overlay.root_committee())
|
|
|
|
def timeout_detected(self, msgs: Set[Timeout]) -> Event:
|
|
"""
|
|
Root committee detected that supermajority of root + its children has timed out
|
|
The view has failed and this information is sent to all participants along with the information
|
|
necessary to reconstruct the new overlay
|
|
|
|
"""
|
|
assert len(msgs) == self.overlay.leader_super_majority_threshold(self.id)
|
|
assert all(msg.view >= self.current_view for msg in msgs)
|
|
assert len(set(msg.view for msg in msgs)) == 1
|
|
assert self.overlay.is_member_of_root_committee(self.id)
|
|
|
|
timeout_qc = self.build_timeout_qc(msgs, self.id)
|
|
return BroadCast(payload=timeout_qc) # we broadcast so all nodes can get ready for voting on a new view
|
|
# Note that receive_timeout qc should be called for root nodes as well
|
|
|
|
# noinspection PyTypeChecker
|
|
def approve_new_view(self, timeout_qc: TimeoutQc, new_views: Set[NewView]) -> Event:
|
|
"""
|
|
We will always need for timeout_qc to have been preprocessed by the received_timeout_qc method when the event
|
|
happens before approve_new_view is processed.
|
|
"""
|
|
# newView.view == self.last_timeout_view_qc.view for member of root committee and its children because
|
|
# they have already created the timeout_qc. For other nodes newView.view > self.last_timeout_view_qc.view.
|
|
if self.last_view_timeout_qc is not None:
|
|
assert all(new_view.view > self.last_view_timeout_qc.view for new_view in new_views)
|
|
assert all(new_view.timeout_qc.view == timeout_qc.view for new_view in new_views)
|
|
assert len(new_views) == self.overlay.super_majority_threshold(self.id)
|
|
assert all(self.overlay.is_member_of_child_committee(self.id, new_view.sender) for new_view in new_views)
|
|
# the new view should be for the view successive to the timeout
|
|
assert all(timeout_qc.view + 1 == new_view.view for new_view in new_views)
|
|
view = timeout_qc.view + 1
|
|
assert self.highest_voted_view < view
|
|
|
|
# get the highest qc from the new views
|
|
messages_high_qc = (new_view.high_qc for new_view in new_views)
|
|
high_qc = max(
|
|
[timeout_qc.high_qc, *messages_high_qc],
|
|
key=lambda qc: qc.view
|
|
)
|
|
self.update_high_qc(high_qc)
|
|
timeout_msg = NewView(
|
|
view=view,
|
|
# TODO: even if this event is processed "later", we should not allow high_qc.view to be >= timeout_qc.view
|
|
high_qc=self.local_high_qc,
|
|
sender=self.id,
|
|
timeout_qc=timeout_qc,
|
|
)
|
|
|
|
# This checks if a node has already incremented its voted view by local_timeout. If not then it should
|
|
# do it now to avoid voting in this view.
|
|
self.highest_voted_view = max(self.highest_voted_view, view)
|
|
|
|
if self.overlay.is_member_of_root_committee(self.id):
|
|
return Send(payload=timeout_msg, to=[self.overlay.next_leader()])
|
|
return Send(payload=timeout_msg, to=self.overlay.parent_committee(self.id))
|
|
|
|
|
|
|
|
# Just a suggestion that received_timeout_qc can be reused by each node when the process timeout_qc of the NewView msg.
|
|
# TODO: check that receiving (and processing) a timeout qc "in the future" allows to process old(er) blocks
|
|
# e.g. we might still need access to the old leader schedule to validate qcs
|
|
def receive_timeout_qc(self, timeout_qc: TimeoutQc):
|
|
if timeout_qc.view < self.current_view:
|
|
return
|
|
new_high_qc = timeout_qc.high_qc
|
|
self.update_high_qc(new_high_qc)
|
|
self.update_timeout_qc(timeout_qc)
|
|
# Update our current view and go ahead with the next step
|
|
self.update_current_view_from_timeout_qc(timeout_qc)
|
|
# self.rebuild_overlay_from_timeout_qc(timeout_qc)
|
|
|
|
def rebuild_overlay_from_timeout_qc(self, timeout_qc: TimeoutQc):
|
|
assert timeout_qc.view >= self.current_view
|
|
self.overlay = Overlay()
|
|
|
|
@staticmethod
|
|
def build_timeout_qc(msgs: Set[Timeout], sender: Id) -> TimeoutQc:
|
|
msgs = list(msgs)
|
|
return TimeoutQc(
|
|
view=msgs[0].view,
|
|
high_qc=max(msgs, key=lambda x: x.high_qc.view).high_qc,
|
|
qc_views=[msg.view for msg in msgs],
|
|
sender_ids={msg.sender for msg in msgs},
|
|
sender=sender,
|
|
)
|
|
|
|
def update_current_view_from_timeout_qc(self, timeout_qc: TimeoutQc):
|
|
self.current_view = timeout_qc.view + 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
pass
|