tendermint/consensus/definitions.tex

\section{Definitions} \label{sec:definitions}

\subsection{Model}

We consider a system of processes that communicate by exchanging messages.
Processes can be correct or faulty, where a faulty process can behave in an
arbitrary way, i.e., Byzantine faults. We assume that each process
has some amount of voting power (voting power of a process can be $0$).
Processes in our model are not part of a single administrative domain;
therefore we cannot enforce a direct network connectivity between all
processes. Instead, we assume that each process is connected to a subset of
processes called peers, such that there is an indirect communication channel
between all correct processes. Communication between processes is established
using a gossip protocol \cite{Dem1987:gossip}.

Formally, we model the network communication using the \emph{partially
synchronous system model}~\cite{DLS88:jacm}: in all executions of the system
there is a bound $\Delta$ and an instant GST (Global Stabilization Time) such
that all communication among correct processes after GST is reliable and
$\Delta$-timely, i.e., if a correct process $p$ sends message $m$ at time $t
\ge GST$ to correct process $q$, then $q$ will receive $m$ before $t +
\Delta$\footnote{Note that as we do not assume direct communication channels
    among all correct processes, this implies that before the message $m$
    reaches $q$, it might pass through a number of correct processes that will
forward the message $m$ using gossip protocol towards $q$.}. Messages among
correct processes can be delayed, dropped or duplicated before GST.
Spoofing/impersonation attacks are assumed to be impossible at all times due to
the use of public-key cryptography. The bound $\Delta$ and GST are system
parameters whose values are not required to be known for the safety of our
algorithm. Termination of the algorithm is guaranteed within a bounded duration
after GST.  In practice, the algorithm will work correctly in the slightly
weaker variant of the model where the system alternates between (long enough)
good periods (corresponds to the \emph{after} GST period where system is
reliable and $\Delta$-timely) and bad periods (corresponds to the period
\emph{before} GST during which the system is asynchronous and messages can be
lost), but consideration of the GST model simplifies the discussion.  

We assume that process steps (which might include sending and receiving
messages) take zero time.  Processes are equipped with clocks so they can
measure local timeouts.  All protocol messages are signed, i.e., when a correct
process $q$ receives a signed message $m$ from its peer, the process $q$ can
verify who was the original sender of the message $m$.

The details of the Tendermint gossip protocol will be discussed in a separate
technical report. For the sake of this paper it is sufficient to assume that
messages are being gossiped between processes and the following property holds
(in addition to the partial synchrony network assumptions):

\begin{itemize} \item \emph{Gossip communication:} If a correct process $p$
    receives some message $m$ at time $t$, all correct processes will receive
    $m$ before $max\{t, GST\} + \Delta$.    \end{itemize}


%Messages that are being gossiped are created by the consensus layer. We can
    %think about consensus protocol as a content creator, which %defines what
    %messages should be disseminated using the gossip protocol. A correct
    %process creates the message for dissemination either i) %explicitly, by
    %invoking \emph{send} function as part of the consensus protocol or ii)
    %implicitly, by receiving a message from some other %process. Note that in
    %the case ii) gossiping of messages is implicit, i.e., it happens without
    %explicit send clause in the consensus algorithm %whenever a correct
    %process receives some messages in the consensus algorithm\footnote{If a
    %message is received by a correct process at %the consensus level then it
    %is considered valid from the protocol point of view, i.e., it has a
    %correct signature, a proper message structure %and a valid height and
    %round number.}. 

%\item Processes keep resending messages (in case of failures or message loss)
    %until all its peers get them. This ensures that every message %sent or
    %received by a correct process is eventually received by all correct
    %processes. 

\subsection{State Machine Replication}

State machine replication (SMR) is a general approach for replicating services
modeled as a deterministic state machine~\cite{Lam78:cacm,Sch90:survey}.  The
key idea of this approach is to guarantee that all replicas start in the same
state and then apply requests from clients in the same order, thereby
guaranteeing that the replicas' states will not diverge.  Following
Schneider~\cite{Sch90:survey}, we note that the following is key for
implementing a replicated state machine tolerant to (Byzantine) faults:

\begin{itemize} \item \emph{Replica Coordination.} All [non-faulty] replicas
    receive and process the same sequence of requests.  \end{itemize}

Moreover, as Schneider also notes, this property can be decomposed into two
parts, \emph{Agreement} and \emph{Order}: Agreement requires all (non-faulty)
replicas to receive all requests, and Order requires that the order of received
requests is the same at all replicas.

There is an additional requirement that needs to be ensured by Byzantine
tolerant state machine replication: only requests (called transactions in the
Tendermint terminology) proposed by clients are executed. In Tendermint,
transaction verification is the responsibility of the service that is being
replicated; upon receiving a transaction from the client, the Tendermint
process will ask the service if the request is valid, and only valid requests
will be processed. 

 \subsection{Consensus} \label{sec:consensus}

Tendermint solves state machine replication by sequentially executing consensus
instances to agree on each block of transactions that are
then executed by the service being replicated. We consider a variant of the
Byzantine consensus problem called Validity Predicate-based Byzantine consensus
that is motivated by blockchain systems~\cite{GLR17:red-belly-bc}. The problem
is defined by an agreement, a termination, and a validity property.

 \begin{itemize} \item \emph{Agreement:} No two correct processes decide on
         different values.  \item \emph{Termination:} All correct processes
         eventually decide on a value.  \item \emph{Validity:} A decided value
             is valid, i.e., it satisfies the predefined predicate denoted
             \emph{valid()}.  \end{itemize}

 This variant of the Byzantine consensus problem has an application-specific
 \emph{valid()} predicate to indicate whether a value is valid. In the context
 of blockchain systems, for example, a value is not valid if it does not
 contain an appropriate hash of the last value (block) added to the blockchain.