Nomination prototype

src/herder/Herder.h

@@ -172,6 +172,11 @@ class Herder
     // sender in the pending or recent tx sets.
     virtual SequenceNumber getMaxSeqInPendingTxs(AccountID const&) = 0;
 
+    // If the node has asked about a tx set with the given hash, return the
+    // highest slot asked about for that tx set, otherwise return 0. Used for
+    // deciding what get tx set requests to accept.
+    virtual uint64 getLastSeenSlotIndexForTxSet(Hash const& hash) = 0;
+
     // Returns sequence number for most recent completed checkpoint that the
     // node knows about, as derived from
     // trackingConsensusLedgerIndex

src/herder/HerderImpl.cpp

@@ -795,6 +795,17 @@ HerderImpl::recvSCPEnvelope(SCPEnvelope const& envelope)
         {
             std::string txt("FETCHING");
             ZoneText(txt.c_str(), txt.size());
+            // If nomination, we should still process this.
+            if (envelope.statement.pledges.type() == SCP_ST_NOMINATE)
+            {
+                auto qSetHash = Slot::getCompanionQuorumSetHashFromStatement(
+                    envelope.statement);
+                auto qSet = mApp.getHerder().getQSet(qSetHash);
+                if (qSet != nullptr)
+                {
+                    processSCPQueue();
+                }
+            }
         }
         else if (status == Herder::ENVELOPE_STATUS_PROCESSED)
         {
@@ -1220,6 +1231,12 @@ HerderImpl::getMaxSeqInPendingTxs(AccountID const& acc)
     return mTransactionQueue.getAccountTransactionQueueInfo(acc).mMaxSeq;
 }
 
+uint64
+HerderImpl::getLastSeenSlotIndexForTxSet(Hash const& hash)
+{
+    return mPendingEnvelopes.getLastSeenSlotIndexForTxSet(hash);
+}
+
 uint32_t
 HerderImpl::getMostRecentCheckpointSeq()
 {

src/herder/HerderImpl.h

@@ -150,6 +150,7 @@ class HerderImpl : public Herder
                                      SCPStatement const& newSt) override;
 
     SequenceNumber getMaxSeqInPendingTxs(AccountID const&) override;
+    uint64 getLastSeenSlotIndexForTxSet(Hash const& hash) override;
 
     uint32_t getMostRecentCheckpointSeq() override;
 

src/herder/HerderSCPDriver.cpp

@@ -137,10 +137,9 @@ class SCPHerderEnvelopeWrapper : public SCPEnvelopeWrapper
             }
             else
             {
-                throw std::runtime_error(fmt::format(
-                    FMT_STRING("SCPHerderEnvelopeWrapper: Wrapping an unknown "
-                               "tx set {} from envelope"),
-                    hexAbbrev(txSetH)));
+                CLOG_TRACE(Herder,
+                           "unknown tx set {}, we might still able to vote",
+                           hexAbbrev(txSetH));
             }
         }
     }
@@ -314,10 +313,9 @@ HerderSCPDriver::validateValueHelper(uint64_t slotIndex, StellarValue const& b,
 
     if (!txSet)
     {
-        CLOG_ERROR(Herder, "validateValue i:{} unknown txSet {}", slotIndex,
+        CLOG_TRACE(Herder, "validateValue i:{} unknown txSet {}", slotIndex,
                    hexAbbrev(txSetHash));
-
-        res = SCPDriver::kInvalidValue;
+        res = SCPDriver::kVoteToNominate;
     }
     else if (!checkAndCacheTxSetValid(txSet, closeTimeOffset))
     {
@@ -439,7 +437,7 @@ HerderSCPDriver::extractValidValue(uint64_t slotIndex, Value const& value)
     return res;
 }
 
-// value marshaling
+// value marshalling
 
 std::string
 HerderSCPDriver::toShortString(NodeID const& pk) const
@@ -1178,10 +1176,8 @@ class SCPHerderValueWrapper : public ValueWrapper
         mTxSet = mHerder.getTxSet(sv.txSetHash);
         if (!mTxSet)
         {
-            throw std::runtime_error(fmt::format(
-                FMT_STRING(
-                    "SCPHerderValueWrapper tried to bind an unknown tx set {}"),
-                hexAbbrev(sv.txSetHash)));
+            CLOG_TRACE(Herder, "unknown tx set {}, we might vote to nominate",
+                       hexAbbrev(sv.txSetHash));
         }
     }
 };

src/herder/PendingEnvelopes.cpp

@@ -234,13 +234,21 @@ PendingEnvelopes::addTxSet(Hash const& hash, uint64 lastSeenSlotIndex,
     mTxSetFetcher.recv(hash, mFetchTxSetTimer);
 }
 
+uint64
+
+PendingEnvelopes::getLastSeenSlotIndexForTxSet(Hash const& hash)
+{
+    auto lastSeenSlotIndex = mTxSetFetcher.getLastSeenSlotIndex(hash);
+    return lastSeenSlotIndex;
+}
+
 bool
 PendingEnvelopes::recvTxSet(Hash const& hash, TxSetFrameConstPtr txset)
 {
     ZoneScoped;
     CLOG_TRACE(Herder, "Got TxSet {}", hexAbbrev(hash));
 
-    auto lastSeenSlotIndex = mTxSetFetcher.getLastSeenSlotIndex(hash);
+    auto lastSeenSlotIndex = getLastSeenSlotIndexForTxSet(hash);
     if (lastSeenSlotIndex == 0)
     {
         return false;
@@ -361,9 +369,26 @@ PendingEnvelopes::recvSCPEnvelope(SCPEnvelope const& envelope)
         }
         else
         {
-            // else just keep waiting for it to come in
-            // and refresh fetchers as needed
-            startFetch(envelope);
+            if (envelope.statement.pledges.type() == SCP_ST_NOMINATE)
+            {
+                auto qSetH = Slot::getCompanionQuorumSetHashFromStatement(
+                    envelope.statement);
+                auto mQSet = mApp.getHerder().getQSet(qSetH);
+                if (mQSet != nullptr)
+                {
+                    // The qset has been fetched.
+                    // Not all tx sets have been fetched,
+                    // but we should process this nomination statement
+                    // in case we can vote for some/all of them.
+                    envelopeReady(envelope);
+                }
+            }
+            else
+            {
+                // else just keep waiting for it to come in
+                // and refresh fetchers as needed
+                startFetch(envelope);
+            }
         }
 
         return Herder::ENVELOPE_STATUS_FETCHING;

src/herder/PendingEnvelopes.h

@@ -164,6 +164,8 @@ class PendingEnvelopes
     TxSetFrameConstPtr putTxSet(Hash const& hash, uint64 slot,
                                 TxSetFrameConstPtr txset);
 
+    uint64 getLastSeenSlotIndexForTxSet(Hash const& hash);
+
     /**
      * Check if @p txset identified by @p hash was requested before from peers.
      * If not, ignores that @p txset. If it was requested, calls

src/herder/TxSetFrame.cpp

@@ -233,18 +233,21 @@ TxSetFrame::checkValidStructure() const
 TxSetFrameConstPtr
 TxSetFrame::makeFromTransactions(TxSetFrame::Transactions txs, Application& app,
                                  uint64_t lowerBoundCloseTimeOffset,
-                                 uint64_t upperBoundCloseTimeOffset)
+                                 uint64_t upperBoundCloseTimeOffset,
+                                 bool forceIsNotGeneralized)
 {
     Transactions invalid;
     return TxSetFrame::makeFromTransactions(txs, app, lowerBoundCloseTimeOffset,
-                                            upperBoundCloseTimeOffset, invalid);
+                                            upperBoundCloseTimeOffset, invalid,
+                                            forceIsNotGeneralized);
 }
 
 TxSetFrameConstPtr
 TxSetFrame::makeFromTransactions(Transactions txs, Application& app,
                                  uint64_t lowerBoundCloseTimeOffset,
                                  uint64_t upperBoundCloseTimeOffset,
-                                 Transactions& invalidTxs)
+                                 Transactions& invalidTxs,
+                                 bool forceIsNotGeneralized)
 {
     TxSetFrame::TxPhases phases;
     phases.emplace_back(txs);
@@ -257,38 +260,47 @@ TxSetFrame::makeFromTransactions(Transactions txs, Application& app,
     }
     TxSetFrame::TxPhases invalid;
     invalid.resize(phases.size());
-    auto res =
-        TxSetFrame::makeFromTransactions(phases, app, lowerBoundCloseTimeOffset,
-                                         upperBoundCloseTimeOffset, invalid);
+    auto res = TxSetFrame::makeFromTransactions(
+        phases, app, lowerBoundCloseTimeOffset, upperBoundCloseTimeOffset,
+        invalid, forceIsNotGeneralized);
     invalidTxs = invalid[0];
     return res;
 }
 #endif
 
 TxSetFrame::TxSetFrame(LedgerHeaderHistoryEntry const& lclHeader,
-                       TxPhases const& txs)
-    : TxSetFrame(protocolVersionStartsFrom(lclHeader.header.ledgerVersion,
-                                           SOROBAN_PROTOCOL_VERSION),
+                       TxPhases const& txs, bool forceIsNotGeneralized)
+    : TxSetFrame(!forceIsNotGeneralized &&
+                     protocolVersionStartsFrom(lclHeader.header.ledgerVersion,
+                                               SOROBAN_PROTOCOL_VERSION),
                  lclHeader.hash, txs)
 {
+// For now, forceIsNotGeneralized is only used for testing. It's quite hacky so
+// we should probably do some refactoring.
+#ifndef BUILD_TESTS
+    releaseAssert(!forceIsNotGeneralized)
+#endif 
 }
 
 TxSetFrameConstPtr
 TxSetFrame::makeFromTransactions(TxPhases const& txPhases, Application& app,
                                  uint64_t lowerBoundCloseTimeOffset,
-                                 uint64_t upperBoundCloseTimeOffset)
+                                 uint64_t upperBoundCloseTimeOffset,
+                                 bool forceIsNotGeneralized)
 {
     TxPhases invalidTxs;
     invalidTxs.resize(txPhases.size());
     return makeFromTransactions(txPhases, app, lowerBoundCloseTimeOffset,
-                                upperBoundCloseTimeOffset, invalidTxs);
+                                upperBoundCloseTimeOffset, invalidTxs,
+                                forceIsNotGeneralized);
 }
 
 TxSetFrameConstPtr
 TxSetFrame::makeFromTransactions(TxPhases const& txPhases, Application& app,
                                  uint64_t lowerBoundCloseTimeOffset,
                                  uint64_t upperBoundCloseTimeOffset,
-                                 TxPhases& invalidTxs)
+                                 TxPhases& invalidTxs,
+                                 bool forceIsNotGeneralized)
 {
     releaseAssert(txPhases.size() == invalidTxs.size());
     releaseAssert(txPhases.size() <=
@@ -318,7 +330,7 @@ TxSetFrame::makeFromTransactions(TxPhases const& txPhases, Application& app,
     // This may cause leaks in case of exceptions, so keep the constructors
     // simple and exception-safe.
     std::shared_ptr<TxSetFrame> txSet(
-        new TxSetFrame(lclHeader, validatedPhases));
+        new TxSetFrame(lclHeader, validatedPhases, forceIsNotGeneralized));
     txSet->applySurgePricing(app);
 
     // Do the roundtrip through XDR to ensure we never build an incorrect tx set
@@ -349,7 +361,7 @@ TxSetFrame::makeFromTransactions(TxPhases const& txPhases, Application& app,
     }
     valid = valid && outputTxSet->checkValid(app, lowerBoundCloseTimeOffset,
                                              upperBoundCloseTimeOffset);
-    if (!valid)
+    if (!valid && !forceIsNotGeneralized)
     {
         throw std::runtime_error("Created invalid tx set frame");
     }
@@ -1036,7 +1048,9 @@ TxSetFrame::toXDR(TransactionSet& txSet) const
 {
     ZoneScoped;
     releaseAssert(!isGeneralizedTxSet());
+#ifndef BUILD_TESTS
     releaseAssert(mTxPhases.size() == 1);
+#endif
     auto& txs = mTxPhases[0];
     txSet.txs.resize(xdr::size32(txs.size()));
     auto sortedTxs = TxSetUtils::sortTxsInHashOrder(txs);

src/herder/TxSetFrame.h

@@ -47,14 +47,14 @@ class TxSetFrame : public NonMovableOrCopyable
     // **Note**: the output `TxSetFrame` will *not* contain the input
     // transaction pointers.
     static TxSetFrameConstPtr
-    makeFromTransactions(TxPhases const& txPhases, Application& app,
-                         uint64_t lowerBoundCloseTimeOffset,
-                         uint64_t upperBoundCloseTimeOffset);
-    static TxSetFrameConstPtr
     makeFromTransactions(TxPhases const& txPhases, Application& app,
                          uint64_t lowerBoundCloseTimeOffset,
                          uint64_t upperBoundCloseTimeOffset,
-                         TxPhases& invalidTxsPerPhase);
+                         bool forceIsNotGeneralized = false);
+    static TxSetFrameConstPtr makeFromTransactions(
+        TxPhases const& txPhases, Application& app,
+        uint64_t lowerBoundCloseTimeOffset, uint64_t upperBoundCloseTimeOffset,
+        TxPhases& invalidTxsPerPhase, bool forceIsNotGeneralized = false);
 
     // Creates a legacy (non-generalized) TxSetFrame from the transactions that
     // are trusted to be valid. Validation and filtering are not performed.
@@ -159,17 +159,19 @@ class TxSetFrame : public NonMovableOrCopyable
     // Test helper that only checks the XDR structure validitiy without
     // validating internal transactions.
     virtual bool checkValidStructure() const;
-    static TxSetFrameConstPtr
-    makeFromTransactions(Transactions txs, Application& app,
-                         uint64_t lowerBoundCloseTimeOffset,
-                         uint64_t upperBoundCloseTimeOffset);
+    void computeContentsHashForTesting();
+    static TxSetFrameConstPtr makeFromTransactions(
+        Transactions txs, Application& app, uint64_t lowerBoundCloseTimeOffset,
+        uint64_t upperBoundCloseTimeOffset, bool forceIsNotGeneralized = false);
     static TxSetFrameConstPtr makeFromTransactions(
         Transactions txs, Application& app, uint64_t lowerBoundCloseTimeOffset,
-        uint64_t upperBoundCloseTimeOffset, Transactions& invalidTxs);
+        uint64_t upperBoundCloseTimeOffset, Transactions& invalidTxs,
+        bool forceIsNotGeneralized = false);
 #endif
 
   protected:
-    TxSetFrame(LedgerHeaderHistoryEntry const& lclHeader, TxPhases const& txs);
+    TxSetFrame(LedgerHeaderHistoryEntry const& lclHeader, TxPhases const& txs,
+               bool forceIsNotGeneralized = false);
     TxSetFrame(bool isGeneralized, Hash const& previousLedgerHash,
                TxPhases const& txs);