#1003 use last committed blck timestamp; update parsing from serialized blocks; update tests

Author: PropzSaladaz

bite/BiteCommittedBlockSerializer.cpp

@@ -90,7 +90,7 @@ void BiteCommittedBlockSerializer::serializedSanityCheck(const ptr<vector<uint8_
 
 ptr<CommittedBlock> BiteCommittedBlockSerializer::deserialize(const ptr<vector<uint8_t> > &_serializedBlock,
                                                               const ptr<CryptoManager> &_cryptoManager,
-                                                              const ptr<BiteManager> _biteManager, bool _verifySig) {
+                                                              const ptr<BiteManager> _biteManager, bool _verifySig ) {
     CHECK_ARGUMENT(_serializedBlock);
     CHECK_ARGUMENT(_cryptoManager);
     CHECK_ARGUMENT(_biteManager);
@@ -148,9 +148,20 @@ ptr<CommittedBlock> BiteCommittedBlockSerializer::deserialize(const ptr<vector<u
         BiteAESKeySerializer::deserialize(fbAesKeys, *decryptedAesKeyList);
     }
 
+#ifdef BITE2
+    // Committed block format is self-describing for BITE2:
+    // reencryption signature is present only for BITE2-format committed blocks.
+    // FOr such block to have been comitted, it must have been after bite2PatchTimestamp condition
+    bool isBite2PatchEnabledForBlock = blockHeader->getReencryptionThresholdSig().has_value();
+#endif
 
     auto decryptedTransactionDataFields = _biteManager->verifyAndDecryptTransactionList(
-        *transactionList, *decryptedAesKeyList, blockHeader->getEpochID(), blockHeader->getTimeStamp() );
+        *transactionList, *decryptedAesKeyList, (uint64_t)blockHeader->getEpochID()
+#ifdef BITE2
+        , isBite2PatchEnabledForBlock 
+#endif
+    );
+    
     ptr<CommittedBlock> block = nullptr;
 
     try {

bite/BiteManager.cpp

@@ -54,10 +54,9 @@ void BiteManager::parseBITETransactions(
     ptr<BlockProposal> _proposal) {
 
     BiteRuntimeContext runtimeCtx {
-        .currentEpoch = _proposal->getEpochID()
+        .currentEpoch = schain.getNode()->getCurrentEpochId()
 #ifdef BITE2
-        ,
-        .isBite2PatchEnabled = schain.bite2Patch( _proposal->getTimeStampS() )
+        , .isBite2PatchEnabled = schain.bite2Patch( schain.getLastCommittedBlockTimeStamp().getS() )
 #endif
     };
 
@@ -175,15 +174,20 @@ std::shared_ptr<DecryptedAESKeyList> BiteManager::mergeAESKeys(
 DecryptedTransactions BiteManager::verifyAndDecryptTransactionList(
         const TransactionList &_transactionList,
         const DecryptedAESKeyList &_aesKeys,
-        epoch_id _epochId,
-        uint64_t _blockTimestampS ) {
+        uint64_t _epochId
+#ifdef BITE2
+        , bool _isBite2PatchEnabledForBlock
+#endif
+    ) {
 
     MONITOR(__CLASS_NAME__, __FUNCTION__);
 
     BiteRuntimeContext runtimeCtx {
         .currentEpoch = _epochId,
-        .threadPoolExecutor = threadPoolExecutor,
-        .isBite2PatchEnabled = schain.bite2Patch( _blockTimestampS )
+        .threadPoolExecutor = threadPoolExecutor
+#ifdef BITE2
+        , .isBite2PatchEnabled = _isBite2PatchEnabledForBlock
+#endif
     };
 
     return biteEngine.decryptTransactionsListInParallel(

bite/BiteManager.h

@@ -75,7 +75,7 @@ class BiteManager {
 
     [[nodiscard]] DecryptedTransactions verifyAndDecryptTransactionList(
         const TransactionList &_transactionList, const DecryptedAESKeyList &_aesKeys,
-        epoch_id _epochId, uint64_t _blockTimestampS );
+        uint64_t _epochId, bool _isBite2PatchEnabledForBlock );
 
 
     // ============== Getters ============== //

chains/Schain.cpp

@@ -560,6 +560,10 @@ void Schain::blockCommitArrived(block_id _committedBlockID, schain_index _propos
     if ( isBite2PatchEnabled ) {
         CHECK_ARGUMENT(_reencryptionThresholdSig)
     }
+    else {
+        // enforce bite2 blocks are rejected if we are not yet in bite2 patch
+        CHECK_ARGUMENT(!_reencryptionThresholdSig)
+    }
 #endif
 #endif
 
@@ -950,13 +954,12 @@ void Schain::saveBlock(const ptr<CommittedBlock> &_block) {
 
     try {
         checkForExit();
-        // save in block db
-        getNode()->getBlockDB()->saveBlock(_block);
 
 #ifdef BITE2
+        // save random before saving block. If block is ever available in db, random should also be
         // compute reencryption random from block signature & save in random db
         std::optional<string> reencryptionSignature = _block->getReencryptionThresholdSig();
-        bool isBite2PatchEnabled = bite2Patch(_block->getTimeStampS());
+        bool isBite2PatchEnabled = bite2Patch( getLastCommittedBlockTimeStamp().getS() );
         if (isBite2PatchEnabled) {
             CHECK_STATE2(reencryptionSignature.has_value(), 
                 "BITE2 patch is enabled but reencryption signature is missing for block " + to_string( _block->getBlockID() ));
@@ -967,7 +970,15 @@ void Schain::saveBlock(const ptr<CommittedBlock> &_block) {
             getSchain()->getNode()->getRandomDB()->writeDomainRandom(
                 blockconsensus::REENCRYPTION_RANDOM_DOMAIN, _block->getBlockID(), random );
         }
+        else {
+            CHECK_STATE2(!reencryptionSignature.has_value(), 
+                "BITE2 patch is not enabled but reencryption signature is present for block " + to_string( _block->getBlockID() ));
+        }
 #endif
+
+        // save in block db
+        getNode()->getBlockDB()->saveBlock(_block);
+
     } catch (ExitRequestedException &) {
         throw;
     } catch (...) {
@@ -1233,12 +1244,18 @@ void Schain::bootstrap(block_id _lastCommittedBlockID, uint64_t _lastCommittedBl
     }
 
 
-    // Step 0 Workaround for the fact that skaled does not yet save timestampMs
-
-    if (_lastCommittedBlockTimeStampMs == 0 && _lastCommittedBlockID > 0) {
+    // Step 0: recover missing timestamp fields from consensus DB block if needed.
+    // For test/continue startup we may only know the last committed block id.
+    if ( _lastCommittedBlockID > 0 &&
+         ( _lastCommittedBlockTimeStamp == 0 || _lastCommittedBlockTimeStampMs == 0 ) ) {
         auto block = getNode()->getBlockDB()->getBlock(_lastCommittedBlockID, getCryptoManager());
         if (block) {
-            _lastCommittedBlockTimeStampMs = block->getTimeStampMs();
+            if ( _lastCommittedBlockTimeStamp == 0 ) {
+                _lastCommittedBlockTimeStamp = block->getTimeStampS();
+            }
+            if ( _lastCommittedBlockTimeStampMs == 0 ) {
+                _lastCommittedBlockTimeStampMs = block->getTimeStampMs();
+            }
         };
     }
 
@@ -1262,12 +1279,16 @@ void Schain::bootstrap(block_id _lastCommittedBlockID, uint64_t _lastCommittedBl
         while (lastCommittedBlockIDInConsensus > _lastCommittedBlockID)
 
             try {
+                bool isBite2PatchEnabledForBlock = false;
+#ifdef BITE2
+                isBite2PatchEnabledForBlock = bite2Patch( getLastCommittedBlockTimeStamp().getS() );
+#endif
                 auto block = getNode()->getBlockDB()->getBlock(
-                    _lastCommittedBlockID + 1, getCryptoManager());
+                    _lastCommittedBlockID + 1, getCryptoManager() );
                 CHECK_STATE2(block, "No block in consensus, repair needed");
 #ifdef BITE2
-                if ( bite2Patch( block->getTimeStampS() ) ) {
-                    auto reencryptionSignature = block->getReencryptionThresholdSig();
+                auto reencryptionSignature = block->getReencryptionThresholdSig();
+                if ( isBite2PatchEnabledForBlock ) {
                     CHECK_STATE2( reencryptionSignature.has_value(),
                         "BITE2 patch is enabled but reencryption signature is missing for replayed block " +
                             to_string( (uint64_t) block->getBlockID() ) );
@@ -1279,6 +1300,11 @@ void Schain::bootstrap(block_id _lastCommittedBlockID, uint64_t _lastCommittedBl
                     getNode()->getRandomDB()->writeDomainRandom(
                         blockconsensus::REENCRYPTION_RANDOM_DOMAIN, block->getBlockID(), random );
                 }
+                else {
+                    CHECK_STATE2( !reencryptionSignature.has_value(),
+                        "BITE2 patch is not enabled but reencryption signature is present for replayed block " +
+                            to_string( (uint64_t) block->getBlockID() ) );
+                }
 #endif
                 pushBlockToExtFace(block);
                 _lastCommittedBlockID = _lastCommittedBlockID + 1;
@@ -1650,8 +1676,12 @@ void Schain::finalizeDecidedAndSignedBlockInThread(block_id _blockId, schain_ind
         CHECK_STATE(keys);
 
         auto transactions = proposal->getTransactionList();
+        bool isBite2PatchEnabledForBlock = false;
+#ifdef BITE2
+        isBite2PatchEnabledForBlock = bite2Patch( getLastCommittedBlockTimeStamp().getS() );
+#endif
         auto decryptedTransactions = getBiteManager()->verifyAndDecryptTransactionList(
-            *transactions, (*keys), proposal->getEpochID(), proposal->getTimeStampS() );
+            *transactions, (*keys), (uint64_t)proposal->getEpochID(), isBite2PatchEnabledForBlock );
 #endif
 
         auto daProofSig = getNode()->getDaProofDB()->getDASig( _blockId, _proposerIndex );

datastructures/CommittedBlock.cpp

@@ -213,9 +213,10 @@ ptr<CommittedBlock> CommittedBlock::deserialize(const ptr<vector<uint8_t> > &_se
 #ifdef BITE
                                                 const ptr<BiteManager> &_biteManager,
 #endif
-                                                bool _verifySig) {
+                                                bool _verifySig ) {
 #ifdef BITE
-    return BiteCommittedBlockSerializer::deserialize(_serializedBlock, _manager, _biteManager, _verifySig);
+    return BiteCommittedBlockSerializer::deserialize(
+        _serializedBlock, _manager, _biteManager, _verifySig );
 #endif
 
     CHECK_ARGUMENT(_serializedBlock);

messages/NetworkMessage.cpp

@@ -303,7 +303,7 @@ ptr< NetworkMessage > NetworkMessage::parseMessage(
 #ifdef BITE
     uint64_t epochID;
 #ifdef BITE2
-    string offchainSigShare;
+    string reencryptionSignature;
 #endif // BITE2
 #endif // BITE
     uint64_t blockProposerIndex;
@@ -393,8 +393,18 @@ ptr< NetworkMessage > NetworkMessage::parseMessage(
                 sigShare, srcSchainIndex, ecdsaSig, publicKey, pkSig, _sChain );
         } else if ( type == BasicHeader::BLOCK_SIG_BROADCAST ) {
 #ifdef BITE2
-            if ( d.HasMember( "ofss" ) ) {
-                offchainSigShare = getStringRapid( d, "ofss" );
+            // Only try parsing member if the message is past bite2 patch time
+            if ( _sChain->bite2Patch( _sChain->getLastCommittedBlockTimeStamp().getS() ) ) {
+                if ( d.HasMember( "rsig" ) ) {
+                    reencryptionSignature = getStringRapid( d, "rsig" );
+                }
+                else {
+                    CONS_LOG( warn, "BITE2 patch is enabled but reencryption signature is missing in message for block " + to_string( blockID ) );
+                    CHECK_STATE( false )
+                }
+            }
+            else {
+                CHECK_STATE2( !d.HasMember( "rsig" ), "BITE2 patch is not enabled but reencryption signature is present in message for block " + to_string( blockID ) );
             }
 #endif
             nwkMsg = make_shared< BlockSignBroadcastMessage >( node_id( srcNodeID ),
@@ -406,7 +416,7 @@ ptr< NetworkMessage > NetworkMessage::parseMessage(
                 schain_id( sChainID ), msg_id( msgID ), sigShare, srcSchainIndex, ecdsaSig,
                 publicKey, pkSig, _sChain
 #ifdef BITE2
-                , offchainSigShare
+                , reencryptionSignature
 #endif
                 );
 #ifndef FAIR

node/ConsensusEngine.cpp

@@ -940,38 +940,6 @@ u256 ConsensusEngine::getRandomForBlockId( uint64_t _blockId ) const {
     return 0;  // make compiler happy
 }
 
-ptr< CommittedBlock > ConsensusEngine::getCommittedBlockForBlockId( uint64_t _blockId ) const {
-    CHECK_STATE( nodes.size() > 0 );
-
-    for ( auto&& item : nodes ) {
-        CHECK_STATE( item.second );
-        auto schain = item.second->getSchain();
-        CHECK_STATE( schain );
-        CHECK_STATE( _blockId <= schain->readLastCommittedBlockIDFromDb() );
-
-        auto block = item.second->getBlockDB()->getBlock( _blockId, schain->getCryptoManager() );
-        CHECK_STATE( block );
-        return block;
-    }
-    return nullptr;  // make compiler happy
-}
-
-ptr< CommittedBlock > ConsensusEngine::getCommittedBlockForBlockIdForNode( uint64_t _blockId, node_id _nodeId ) const {
-    CHECK_STATE( nodes.size() >= 1 );
-
-    auto it = nodes.find( _nodeId );
-    CHECK_STATE2( it != nodes.end(), "Node with id " + to_string( _nodeId ) + " not found" );
-
-    CHECK_STATE( it->second );
-    auto schain = it->second->getSchain();
-    CHECK_STATE( schain );
-    CHECK_STATE( _blockId <= schain->readLastCommittedBlockIDFromDb() );
-
-    auto block = it->second->getBlockDB()->getBlock( _blockId, schain->getCryptoManager() );
-    CHECK_STATE( block );
-    return block;
-}
-
 #ifdef BITE2
 
 u256 ConsensusEngine::getReencryptionRandomForBlockId( uint64_t _blockId ) const {

node/ConsensusEngine.h

@@ -46,11 +46,15 @@ using namespace spdlog::level;
 class GlobalThreadRegistry;
 class StorageLimits;
 class CommittedBlock;
+class ConsensusEngineTestAccess;
 
 
 #include "thirdparty/lrucache.hpp"
 
 class ConsensusEngine : public ConsensusInterface {
+    // allow access to private members for testing purposes
+    friend class ConsensusEngineTestAccess;
+
     map< node_id, ptr< Node > > nodes;  // tsafe
 
     mutable cache::lru_cache< uint64_t, u256 > prices;  // tsafe
@@ -321,17 +325,6 @@ class ConsensusEngine : public ConsensusInterface {
 
     std::shared_ptr< std::vector< std::uint8_t > > getSerializedBlock( std::uint64_t _blockNumber );
 
-    /**
-     * @brief Gets the committed block for a given block ID, if available.
-     * Uses the first node available.
-     */
-    ptr< CommittedBlock > getCommittedBlockForBlockId( uint64_t _blockId ) const;
-
-    /**
-     * @brief Gets the committed block for a given block ID and node ID, if available.
-     */
-    ptr< CommittedBlock > getCommittedBlockForBlockIdForNode( uint64_t _blockId, node_id _nodeId ) const;
-
     // return sync information as requested by eth_syncing API of geth
     // if isSyncing is false, all fields will be set to zero.
 

node/Node.cpp

@@ -382,8 +382,8 @@ void Node::startServers( ptr< vector< uint8_t > > _startingFromSnapshotWithThisA
         // now save the block into the blocks dd
         getBlockDB()->saveBlock( block );
 #ifdef BITE2
-        if ( getSchain()->bite2Patch( block->getTimeStampS() ) ) {
-            auto reencryptionSignature = block->getReencryptionThresholdSig();
+        auto reencryptionSignature = block->getReencryptionThresholdSig();
+        if ( getSchain()->bite2Patch( getSchain()->getLastCommittedBlockTimeStamp().getS() ) ) {
             CHECK_STATE2( reencryptionSignature.has_value(),
                 "BITE2 patch is enabled but reencryption signature is missing for imported snapshot block " +
                     to_string( (uint64_t) block->getBlockID() ) );
@@ -395,6 +395,10 @@ void Node::startServers( ptr< vector< uint8_t > > _startingFromSnapshotWithThisA
             getRandomDB()->writeDomainRandom(
                 blockconsensus::REENCRYPTION_RANDOM_DOMAIN, block->getBlockID(), random );
         }
+        else {
+            CHECK_STATE2( !reencryptionSignature.has_value(),
+                "BITE2 patch is not enabled but reencryption signature is present for imported snapshot block " + to_string( (uint64_t) block->getBlockID() ) );
+        }
 #endif
         // now do a sanitity check, that the block was imported OK
         CHECK_STATE2( block->getBlockID() == getBlockDB()->readLastCommittedBlockID(),