Questions about SCP and federated voting steps, with a focus on the Internet-Draft

Question

I recently have studied the Stellar Consensus Protocol (SCP) based on the internet draft here: https://datatracker.ietf.org/doc/draft-mazieres-dinrg-scp/.

I have several questions as follows.

1. In the last paragraph of Section 3.6, a node leaves the PREPARE phase and proceeds to the COMMIT phase when there is some ballot "b" for which the node confirms "prepare(b)" and accepts "commit b". However, SCPPrepare message does not (conceptually) convey "accept commit b", while it is conveyed in SCPCommit message, as far as I understand. Is this correct? It seems a bit odd because the PREPARE phase ends with the aid of SCPCommit message.

2. Regarding the conceptually iterated federated voting over the nomination, ballot, and externalize phases. Please check the following (where x = value and b = ballot), and let me know if I have any misunderstandings.

input "x"
--------------------------- the NOMINATION phase starts
vote "x"
accept "x"
confirm "x"
--------------------------- the PREPARE phase starts
vote "prepare(b)"
accept "prepare(b)"
confirm "prepare(b)"
vote "commit(b)"
accept "commit(b)"
--------------------------- the COMMIT phase starts
confirm "commit(b)"
--------------------------- the EXTERNALIZE phase starts
output "b.value"

3. I cannot fully understand why we need to keep track of the preparedPrime (i.e., p') in the SCPPrepare message. Could you briefly describe an example which motivates the use of p'?

Thanks very much for your time and help!

Answer 1

1. The SCPPrepare message conveys "vote commit ballot ". However, it does not convey "accept commit c" for any c, because if it accepts any commit message then it immediately proceeds to the COMMIT phase and issues SCPCommit instead of SCPPrepare messages. Of course, a node in the PREPARE phase could accept "commit c" for some ballot c after getting SCPCommit messages from a blocking set. The latest draft says this about that situation:

   A node leaves the PREPARE phase and proceeds to the COMMIT phase when
   there is some ballot "b" for which the node confirms "prepare(b)" and
   accepts "commit b".  (If nodes never changed quorum slice mid-
   protocol, it would suffice to accept "commit b".  Also waiting to
   confirm "prepare(b)" makes it easier to recover from liveness
   failures by removing Byzantine faulty nodes from quorum slices.)
   

2. The sequence looks basically okay, but certain things happen concurrently, or at least without intervening protocol messages. For example, "confirm prepare(b)" and "vote commit b" are actually the same message (though the act of the first one happening is what allows the second). Similarly, "accept commit b" happens concurrently with the transition to the COMMIT phase, and "confirm commit b" and "output b.value" both happen concurrently with the transition to the EXTERNALIZE phase.

3. Conceptually, you need to keep track of every single ballot you've ever accepted as aborted. The reason is that if some other node voted "commit b" for some ballot b that was later aborted, that node will be stuck until a blocking set asserts that they have all accepted "abort b." Keeping track of an arbitrary set of accepted aborted ballots could be cumbersome. Fortunately, the prepared predicate is designed in such a way that keeping track of all accepted aborted ballots only requires remembering the top two such ballots with different values. In other words, say the top two you accepted are prepare(<10,x>) and prepare(<7,y>), where x != y. This means you have accepted every ballot under <7,y> as aborted, and every ballot between <7,y> and <10,x> as aborted except those with value x.

Answer 2

As per my understanding, the flow should be like this:

SCP
    NOMINATION
        SCPNominate
            Vote x
            Accept x
            Confirm x
    BALLOTING
        SCPPrepare
            Vote prepare(b)
            Accept prepare(b)
            Confirm prepare(b)/Vote commit(b)
        SCPCommit   
            Accept commit(b)
            Confirms commit(b)
        SCPExternalize
            Outputs b.value