Convert closeTimeMs to unix time in ms

Author: SirTyson

src/bucket/test/BucketTestUtils.cpp

@@ -12,6 +12,7 @@
 #include "ledger/LedgerManager.h"
 #include "ledger/LedgerTxn.h"
 #include "main/Application.h"
+#include "test/TxTests.h"
 #include "test/test.h"
 #include "util/ProtocolVersion.h"
 #include "xdr/Stellar-ledger.h"
@@ -86,9 +87,10 @@ closeLedger(Application& app, std::optional<SecretKey> skToSignValue,
     CLOG_INFO(Bucket, "Artificially closing ledger {} with lcl={}, buckets={}",
               ledgerNum, hexAbbrev(lcl.hash),
               hexAbbrev(app.getBucketManager().getLiveBucketList().getHash()));
-    app.getHerder().externalizeValue(TxSetXDRFrame::makeEmpty(lcl), ledgerNum,
-                                     lcl.header.scpValue.closeTime, upgrades,
-                                     skToSignValue);
+    app.getHerder().externalizeValue(
+        TxSetXDRFrame::makeEmpty(lcl), ledgerNum,
+        txtest::makeConsensusTime(lcl.header.scpValue.closeTime), upgrades,
+        skToSignValue);
     while (lm.getLastClosedLedgerNum() < ledgerNum)
     {
         app.getClock().crank(true);

src/catchup/ApplyCheckpointWork.cpp

@@ -12,6 +12,7 @@
 #include "history/HistoryUtils.h"
 #include "historywork/Progress.h"
 #include "ledger/CheckpointRange.h"
+#include "ledger/LedgerHeaderUtils.h"
 #include "ledger/LedgerManager.h"
 #include "main/Application.h"
 #include "util/GlobalChecks.h"
@@ -286,31 +287,40 @@ ApplyCheckpointWork::getNextLedgerCloseData()
     }
 
     // Check that we use the correct time format in the ledger header.
-    bool const msActive = protocolVersionStartsFrom(
-        lclHeader.header.ledgerVersion, MS_CLOSE_TIME_PROTOCOL_VERSION);
-    if (!validateMsCloseTimeFormat(header.scpValue,
-                                   /*allowMsTime=*/msActive,
-                                   /*allowWholeSecondTime=*/!msActive))
+    if (!hasValidCloseTime(header.scpValue))
     {
         throw std::runtime_error(fmt::format(
-            FMT_STRING("ledger header for {:d} has an invalid ms close time "
-                       "(StellarValue type {:d}, closeTimeMs {:d}) under "
-                       "protocol {:d}"),
-            header.ledgerSeq, static_cast<int32_t>(header.scpValue.ext.v()),
-            getCloseTimeMs(header.scpValue), lclHeader.header.ledgerVersion));
+            FMT_STRING("ledger header for {:d} has inconsistent close time "
+                       "fields: closeTime {:d}, consensus close time {}"),
+            header.ledgerSeq, header.scpValue.closeTime,
+            getConsensusTime(header.scpValue).toString()));
+    }
+
+    bool const hasMsCloseTime = isMsCloseTimeStellarValue(header.scpValue);
+    bool const protocolRequiresMsCloseTime =
+        protocolHasMsCloseTime(lclHeader.header.ledgerVersion);
+    if (hasMsCloseTime != protocolRequiresMsCloseTime)
+    {
+        throw std::runtime_error(fmt::format(
+            FMT_STRING("ledger header for {:d} has a {} close time "
+                       "(StellarValue type {:d}) but protocol {:d} requires a "
+                       "{} close time"),
+            header.ledgerSeq, hasMsCloseTime ? "millisecond" : "whole-second",
+            static_cast<int32_t>(header.scpValue.ext.v()),
+            lclHeader.header.ledgerVersion,
+            protocolRequiresMsCloseTime ? "millisecond" : "whole-second"));
     }
 
-    // Check that close time never decreases
-    if (getCloseTime(header.scpValue) <=
-        getCloseTime(lclHeader.header.scpValue))
+    // Close times must strictly increase from ledger to ledger
+    auto const previousCloseTime = getConsensusTime(lclHeader.header.scpValue);
+    auto const nextCloseTime = getConsensusTime(header.scpValue);
+    if (nextCloseTime <= previousCloseTime)
     {
         throw std::runtime_error(fmt::format(
             FMT_STRING("ledger header for {:d} has a non-advancing close "
-                       "time {:d}.{:03d} (previous {:d}.{:03d})"),
-            header.ledgerSeq, header.scpValue.closeTime,
-            getCloseTimeMs(header.scpValue),
-            lclHeader.header.scpValue.closeTime,
-            getCloseTimeMs(lclHeader.header.scpValue)));
+                       "time {} (previous ledger closed at {})"),
+            header.ledgerSeq, nextCloseTime.toString(),
+            previousCloseTime.toString()));
     }
 
     // We've verified the ledgerHeader (in the "trusted part of history"

src/catchup/CatchupWork.cpp

@@ -19,6 +19,7 @@
 #include "historywork/DownloadVerifyTxResultsWork.h"
 #include "historywork/GetAndUnzipRemoteFileWork.h"
 #include "historywork/GetHistoryArchiveStateWork.h"
+#include "ledger/LedgerHeaderUtils.h"
 #include "ledger/LedgerManager.h"
 #include "main/Application.h"
 #include "main/PersistentState.h"
@@ -69,7 +70,7 @@ setHerderStateTo(FileTransferInfo const& ft, uint32_t ledger, Application& app)
     app.getHerder().setTrackingSCPState(ledger, entry->header.scpValue,
                                         /* isTrackingNetwork */ false);
     CLOG_INFO(History, "Herder state is set! tracking={}, closeTime={}", ledger,
-              entry->header.scpValue.closeTime);
+              getConsensusTime(entry->header.scpValue).toString());
     return true;
 }
 

src/herder/Herder.h

@@ -8,7 +8,6 @@
 #include "Upgrades.h"
 #include "herder/QuorumTracker.h"
 #include "herder/TransactionQueue.h"
-#include "ledger/LedgerHeaderUtils.h"
 #include "lib/json/json-forwards.h"
 #include "overlay/Peer.h"
 #include "overlay/StellarXDR.h"
@@ -29,6 +28,7 @@ struct EmptyTxSet
 };
 using TxSetResult = std::variant<TxSetXDRFrameConstPtr, EmptyTxSet>;
 class Application;
+class ConsensusTime;
 class XDROutputFileStream;
 
 /*
@@ -177,7 +177,7 @@ class Herder
 
     virtual void
     externalizeValue(TxSetXDRFrameConstPtr txSet, uint32_t ledgerSeq,
-                     CloseTime closeTime,
+                     ConsensusTime closeTime,
                      xdr::xvector<UpgradeType, 6> const& upgrades,
                      std::optional<SecretKey> skToSignValue = std::nullopt) = 0;
 
@@ -229,7 +229,7 @@ class Herder
 
     // helper function to craft an SCPValue
     virtual StellarValue
-    makeStellarValue(Hash const& txSetHash, CloseTime closeTime,
+    makeStellarValue(Hash const& txSetHash, ConsensusTime closeTime,
                      xdr::xvector<UpgradeType, 6> const& upgrades,
                      SecretKey const& s) = 0;