Improved history ledger integrity checks. (#149)

* Code cleanup.

* Resolving review comments.

* Ledger history sync validation improvements and resolving review comments.

* Ledger terminology related changes.

* Ledger related terminology change updates.

* Resolving review comments.

src/msg/fbuf/ledger_helpers.cpp

@@ -8,13 +8,13 @@ namespace msg::fbuf::ledger
 {
 
     /**
- * Create ledger from the given proposal struct.
- * @param p The proposal struct to be placed in ledger.
- */
-    void create_ledger_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p, const uint64_t seq_no)
+     * Create ledger block from the given proposal struct.
+     * @param p The proposal struct to be placed in ledger.
+     */
+    void create_ledger_block_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p, const uint64_t seq_no)
     {
-        flatbuffers::Offset<ledger::Ledger> ledger =
-            ledger::CreateLedger(
+        flatbuffers::Offset<ledger::LedgerBlock> ledger =
+            ledger::CreateLedgerBlock(
                 builder,
                 seq_no,
                 p.time,
@@ -27,9 +27,9 @@ namespace msg::fbuf::ledger
         builder.Finish(ledger); // Finished building message content to get serialised content.
     }
 
-    p2p::proposal create_proposal_from_ledger(const std::vector<uint8_t> &ledger_buf)
+    p2p::proposal create_proposal_from_ledger_block(const std::vector<uint8_t> &ledger_buf)
     {
-        auto ledger = msg::fbuf::ledger::GetLedger(ledger_buf.data());
+        auto ledger = msg::fbuf::ledger::GetLedgerBlock(ledger_buf.data());
         p2p::proposal p;
         p.lcl = flatbuff_bytes_to_sv(ledger->lcl());
         p.state = flatbuff_bytes_to_hash(ledger->state());
@@ -37,10 +37,10 @@ namespace msg::fbuf::ledger
         return p;
     }
 
-    bool verify_ledger_buffer(const uint8_t *ledger_buf_ptr, const size_t buf_len)
+    bool verify_ledger_block_buffer(const uint8_t *ledger_buf_ptr, const size_t buf_len)
     {
         flatbuffers::Verifier ledger_verifier(ledger_buf_ptr, buf_len);
-        return VerifyLedgerBuffer(ledger_verifier);
+        return VerifyLedgerBlockBuffer(ledger_verifier);
     }
 
 } // namespace msg::fbuf::ledger

src/msg/fbuf/ledger_helpers.hpp

@@ -8,11 +8,11 @@
 namespace msg::fbuf::ledger
 {
 
-    void create_ledger_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p, const uint64_t seq_no);
+    void create_ledger_block_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p, const uint64_t seq_no);
 
-    p2p::proposal create_proposal_from_ledger(const std::vector<uint8_t> &ledger_buf);
+    p2p::proposal create_proposal_from_ledger_block(const std::vector<uint8_t> &ledger_buf);
 
-    bool verify_ledger_buffer(const uint8_t *ledger_buf_ptr, const size_t buf_len);
+    bool verify_ledger_block_buffer(const uint8_t *ledger_buf_ptr, const size_t buf_len);
 
 } // namespace msg::fbuf::ledger
 

src/msg/fbuf/ledger_schema.fbs

@@ -2,7 +2,7 @@ include "common_schema.fbs";
 
 namespace msg.fbuf.ledger;
 
-table Ledger {
+table LedgerBlock {
     seq_no:uint64;
     time:uint64;
     lcl:[ubyte];
@@ -17,4 +17,4 @@ table RawInputList {
     inputs:[ByteArray];
 }
 
-root_type Ledger;
+root_type LedgerBlock;

src/msg/fbuf/ledger_schema_generated.h

@@ -12,14 +12,14 @@ namespace msg {
 namespace fbuf {
 namespace ledger {
 
-struct Ledger;
-struct LedgerBuilder;
+struct LedgerBlock;
+struct LedgerBlockBuilder;
 
 struct RawInputList;
 struct RawInputListBuilder;
 
-struct Ledger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  typedef LedgerBuilder Builder;
+struct LedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef LedgerBlockBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_SEQ_NO = 4,
     VT_TIME = 6,
@@ -92,43 +92,43 @@ struct Ledger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   }
 };
 
-struct LedgerBuilder {
-  typedef Ledger Table;
+struct LedgerBlockBuilder {
+  typedef LedgerBlock Table;
   flatbuffers::FlatBufferBuilder &fbb_;
   flatbuffers::uoffset_t start_;
   void add_seq_no(uint64_t seq_no) {
-    fbb_.AddElement<uint64_t>(Ledger::VT_SEQ_NO, seq_no, 0);
+    fbb_.AddElement<uint64_t>(LedgerBlock::VT_SEQ_NO, seq_no, 0);
   }
   void add_time(uint64_t time) {
-    fbb_.AddElement<uint64_t>(Ledger::VT_TIME, time, 0);
+    fbb_.AddElement<uint64_t>(LedgerBlock::VT_TIME, time, 0);
   }
   void add_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl) {
-    fbb_.AddOffset(Ledger::VT_LCL, lcl);
+    fbb_.AddOffset(LedgerBlock::VT_LCL, lcl);
   }
   void add_state(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> state) {
-    fbb_.AddOffset(Ledger::VT_STATE, state);
+    fbb_.AddOffset(LedgerBlock::VT_STATE, state);
   }
   void add_users(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> users) {
-    fbb_.AddOffset(Ledger::VT_USERS, users);
+    fbb_.AddOffset(LedgerBlock::VT_USERS, users);
   }
   void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> inputs) {
-    fbb_.AddOffset(Ledger::VT_INPUTS, inputs);
+    fbb_.AddOffset(LedgerBlock::VT_INPUTS, inputs);
   }
   void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> outputs) {
-    fbb_.AddOffset(Ledger::VT_OUTPUTS, outputs);
+    fbb_.AddOffset(LedgerBlock::VT_OUTPUTS, outputs);
   }
-  explicit LedgerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit LedgerBlockBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  flatbuffers::Offset<Ledger> Finish() {
+  flatbuffers::Offset<LedgerBlock> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Ledger>(end);
+    auto o = flatbuffers::Offset<LedgerBlock>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Ledger> CreateLedger(
+inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlock(
     flatbuffers::FlatBufferBuilder &_fbb,
     uint64_t seq_no = 0,
     uint64_t time = 0,
@@ -137,7 +137,7 @@ inline flatbuffers::Offset<Ledger> CreateLedger(
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> users = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> inputs = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> outputs = 0) {
-  LedgerBuilder builder_(_fbb);
+  LedgerBlockBuilder builder_(_fbb);
   builder_.add_time(time);
   builder_.add_seq_no(seq_no);
   builder_.add_outputs(outputs);
@@ -148,7 +148,7 @@ inline flatbuffers::Offset<Ledger> CreateLedger(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<Ledger> CreateLedgerDirect(
+inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlockDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
     uint64_t seq_no = 0,
     uint64_t time = 0,
@@ -162,7 +162,7 @@ inline flatbuffers::Offset<Ledger> CreateLedgerDirect(
   auto users__ = users ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*users) : 0;
   auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*inputs) : 0;
   auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*outputs) : 0;
-  return msg::fbuf::ledger::CreateLedger(
+  return msg::fbuf::ledger::CreateLedgerBlock(
       _fbb,
       seq_no,
       time,
@@ -245,37 +245,37 @@ inline flatbuffers::Offset<RawInputList> CreateRawInputListDirect(
       inputs__);
 }
 
-inline const msg::fbuf::ledger::Ledger *GetLedger(const void *buf) {
-  return flatbuffers::GetRoot<msg::fbuf::ledger::Ledger>(buf);
+inline const msg::fbuf::ledger::LedgerBlock *GetLedgerBlock(const void *buf) {
+  return flatbuffers::GetRoot<msg::fbuf::ledger::LedgerBlock>(buf);
 }
 
-inline const msg::fbuf::ledger::Ledger *GetSizePrefixedLedger(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<msg::fbuf::ledger::Ledger>(buf);
+inline const msg::fbuf::ledger::LedgerBlock *GetSizePrefixedLedgerBlock(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<msg::fbuf::ledger::LedgerBlock>(buf);
 }
 
-inline Ledger *GetMutableLedger(void *buf) {
-  return flatbuffers::GetMutableRoot<Ledger>(buf);
+inline LedgerBlock *GetMutableLedgerBlock(void *buf) {
+  return flatbuffers::GetMutableRoot<LedgerBlock>(buf);
 }
 
-inline bool VerifyLedgerBuffer(
+inline bool VerifyLedgerBlockBuffer(
     flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<msg::fbuf::ledger::Ledger>(nullptr);
+  return verifier.VerifyBuffer<msg::fbuf::ledger::LedgerBlock>(nullptr);
 }
 
-inline bool VerifySizePrefixedLedgerBuffer(
+inline bool VerifySizePrefixedLedgerBlockBuffer(
     flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<msg::fbuf::ledger::Ledger>(nullptr);
+  return verifier.VerifySizePrefixedBuffer<msg::fbuf::ledger::LedgerBlock>(nullptr);
 }
 
-inline void FinishLedgerBuffer(
+inline void FinishLedgerBlockBuffer(
     flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<msg::fbuf::ledger::Ledger> root) {
+    flatbuffers::Offset<msg::fbuf::ledger::LedgerBlock> root) {
   fbb.Finish(root);
 }
 
-inline void FinishSizePrefixedLedgerBuffer(
+inline void FinishSizePrefixedLedgerBlockBuffer(
     flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<msg::fbuf::ledger::Ledger> root) {
+    flatbuffers::Offset<msg::fbuf::ledger::LedgerBlock> root) {
   fbb.FinishSizePrefixed(root);
 }
 

src/msg/fbuf/p2pmsg_content.fbs

@@ -72,18 +72,18 @@ enum Ledger_Response_Error : ubyte
 
 table History_Response_Message { //Ledger History request type message schema
     requester_lcl:[ubyte];
-    hist_ledgers:[HistoryLedgerPair];
+    hist_ledger_blocks:[HistoryLedgerBlockPair];
     error: Ledger_Response_Error;
 }
 
-table HistoryLedgerPair { //A key, value pair of byte[].
+table HistoryLedgerBlockPair { //A key, value pair of byte[].
     seq_no:uint64;
-    ledger:HistoryLedger;
+    ledger:HistoryLedgerBlock;
 }
 
-table HistoryLedger {
+table HistoryLedgerBlock {
    lcl:[ubyte];
-   raw_ledger:[ubyte];
+   block_buffer:[ubyte];
 }
 
 table State_Request_Message { //State request message schema

src/msg/fbuf/p2pmsg_content_generated.h

@@ -42,11 +42,11 @@ struct History_Request_MessageBuilder;
 struct History_Response_Message;
 struct History_Response_MessageBuilder;
 
-struct HistoryLedgerPair;
-struct HistoryLedgerPairBuilder;
+struct HistoryLedgerBlockPair;
+struct HistoryLedgerBlockPairBuilder;
 
-struct HistoryLedger;
-struct HistoryLedgerBuilder;
+struct HistoryLedgerBlock;
+struct HistoryLedgerBlockBuilder;
 
 struct State_Request_Message;
 struct State_Request_MessageBuilder;
@@ -992,7 +992,7 @@ struct History_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::T
   typedef History_Response_MessageBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_REQUESTER_LCL = 4,
-    VT_HIST_LEDGERS = 6,
+    VT_HIST_LEDGER_BLOCKS = 6,
     VT_ERROR = 8
   };
   const flatbuffers::Vector<uint8_t> *requester_lcl() const {
@@ -1001,11 +1001,11 @@ struct History_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::T
   flatbuffers::Vector<uint8_t> *mutable_requester_lcl() {
     return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_REQUESTER_LCL);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerPair>> *hist_ledgers() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerPair>> *>(VT_HIST_LEDGERS);
+  const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *hist_ledger_blocks() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *>(VT_HIST_LEDGER_BLOCKS);
   }
-  flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerPair>> *mutable_hist_ledgers() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerPair>> *>(VT_HIST_LEDGERS);
+  flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *mutable_hist_ledger_blocks() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *>(VT_HIST_LEDGER_BLOCKS);
   }
   msg::fbuf::p2pmsg::Ledger_Response_Error error() const {
     return static_cast<msg::fbuf::p2pmsg::Ledger_Response_Error>(GetField<uint8_t>(VT_ERROR, 0));
@@ -1017,9 +1017,9 @@ struct History_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::T
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_REQUESTER_LCL) &&
            verifier.VerifyVector(requester_lcl()) &&
-           VerifyOffset(verifier, VT_HIST_LEDGERS) &&
-           verifier.VerifyVector(hist_ledgers()) &&
-           verifier.VerifyVectorOfTables(hist_ledgers()) &&
+           VerifyOffset(verifier, VT_HIST_LEDGER_BLOCKS) &&
+           verifier.VerifyVector(hist_ledger_blocks()) &&
+           verifier.VerifyVectorOfTables(hist_ledger_blocks()) &&
            VerifyField<uint8_t>(verifier, VT_ERROR) &&
            verifier.EndTable();
   }
@@ -1032,8 +1032,8 @@ struct History_Response_MessageBuilder {
   void add_requester_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> requester_lcl) {
     fbb_.AddOffset(History_Response_Message::VT_REQUESTER_LCL, requester_lcl);
   }
-  void add_hist_ledgers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerPair>>> hist_ledgers) {
-    fbb_.AddOffset(History_Response_Message::VT_HIST_LEDGERS, hist_ledgers);
+  void add_hist_ledger_blocks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>>> hist_ledger_blocks) {
+    fbb_.AddOffset(History_Response_Message::VT_HIST_LEDGER_BLOCKS, hist_ledger_blocks);
   }
   void add_error(msg::fbuf::p2pmsg::Ledger_Response_Error error) {
     fbb_.AddElement<uint8_t>(History_Response_Message::VT_ERROR, static_cast<uint8_t>(error), 0);
@@ -1052,10 +1052,10 @@ struct History_Response_MessageBuilder {
 inline flatbuffers::Offset<History_Response_Message> CreateHistory_Response_Message(
     flatbuffers::FlatBufferBuilder &_fbb,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> requester_lcl = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerPair>>> hist_ledgers = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>>> hist_ledger_blocks = 0,
     msg::fbuf::p2pmsg::Ledger_Response_Error error = msg::fbuf::p2pmsg::Ledger_Response_Error_None) {
   History_Response_MessageBuilder builder_(_fbb);
-  builder_.add_hist_ledgers(hist_ledgers);
+  builder_.add_hist_ledger_blocks(hist_ledger_blocks);
   builder_.add_requester_lcl(requester_lcl);
   builder_.add_error(error);
   return builder_.Finish();
@@ -1064,19 +1064,19 @@ inline flatbuffers::Offset<History_Response_Message> CreateHistory_Response_Mess
 inline flatbuffers::Offset<History_Response_Message> CreateHistory_Response_MessageDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
     const std::vector<uint8_t> *requester_lcl = nullptr,
-    const std::vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerPair>> *hist_ledgers = nullptr,
+    const std::vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *hist_ledger_blocks = nullptr,
     msg::fbuf::p2pmsg::Ledger_Response_Error error = msg::fbuf::p2pmsg::Ledger_Response_Error_None) {
   auto requester_lcl__ = requester_lcl ? _fbb.CreateVector<uint8_t>(*requester_lcl) : 0;
-  auto hist_ledgers__ = hist_ledgers ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerPair>>(*hist_ledgers) : 0;
+  auto hist_ledger_blocks__ = hist_ledger_blocks ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>>(*hist_ledger_blocks) : 0;
   return msg::fbuf::p2pmsg::CreateHistory_Response_Message(
       _fbb,
       requester_lcl__,
-      hist_ledgers__,
+      hist_ledger_blocks__,
       error);
 }
 
-struct HistoryLedgerPair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  typedef HistoryLedgerPairBuilder Builder;
+struct HistoryLedgerBlockPair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef HistoryLedgerBlockPairBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_SEQ_NO = 4,
     VT_LEDGER = 6
@@ -1087,11 +1087,11 @@ struct HistoryLedgerPair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   bool mutate_seq_no(uint64_t _seq_no) {
     return SetField<uint64_t>(VT_SEQ_NO, _seq_no, 0);
   }
-  const msg::fbuf::p2pmsg::HistoryLedger *ledger() const {
-    return GetPointer<const msg::fbuf::p2pmsg::HistoryLedger *>(VT_LEDGER);
+  const msg::fbuf::p2pmsg::HistoryLedgerBlock *ledger() const {
+    return GetPointer<const msg::fbuf::p2pmsg::HistoryLedgerBlock *>(VT_LEDGER);
   }
-  msg::fbuf::p2pmsg::HistoryLedger *mutable_ledger() {
-    return GetPointer<msg::fbuf::p2pmsg::HistoryLedger *>(VT_LEDGER);
+  msg::fbuf::p2pmsg::HistoryLedgerBlock *mutable_ledger() {
+    return GetPointer<msg::fbuf::p2pmsg::HistoryLedgerBlock *>(VT_LEDGER);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
@@ -1102,42 +1102,42 @@ struct HistoryLedgerPair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   }
 };
 
-struct HistoryLedgerPairBuilder {
-  typedef HistoryLedgerPair Table;
+struct HistoryLedgerBlockPairBuilder {
+  typedef HistoryLedgerBlockPair Table;
   flatbuffers::FlatBufferBuilder &fbb_;
   flatbuffers::uoffset_t start_;
   void add_seq_no(uint64_t seq_no) {
-    fbb_.AddElement<uint64_t>(HistoryLedgerPair::VT_SEQ_NO, seq_no, 0);
+    fbb_.AddElement<uint64_t>(HistoryLedgerBlockPair::VT_SEQ_NO, seq_no, 0);
   }
-  void add_ledger(flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedger> ledger) {
-    fbb_.AddOffset(HistoryLedgerPair::VT_LEDGER, ledger);
+  void add_ledger(flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlock> ledger) {
+    fbb_.AddOffset(HistoryLedgerBlockPair::VT_LEDGER, ledger);
   }
-  explicit HistoryLedgerPairBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit HistoryLedgerBlockPairBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  flatbuffers::Offset<HistoryLedgerPair> Finish() {
+  flatbuffers::Offset<HistoryLedgerBlockPair> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<HistoryLedgerPair>(end);
+    auto o = flatbuffers::Offset<HistoryLedgerBlockPair>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<HistoryLedgerPair> CreateHistoryLedgerPair(
+inline flatbuffers::Offset<HistoryLedgerBlockPair> CreateHistoryLedgerBlockPair(
     flatbuffers::FlatBufferBuilder &_fbb,
     uint64_t seq_no = 0,
-    flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedger> ledger = 0) {
-  HistoryLedgerPairBuilder builder_(_fbb);
+    flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlock> ledger = 0) {
+  HistoryLedgerBlockPairBuilder builder_(_fbb);
   builder_.add_seq_no(seq_no);
   builder_.add_ledger(ledger);
   return builder_.Finish();
 }
 
-struct HistoryLedger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  typedef HistoryLedgerBuilder Builder;
+struct HistoryLedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef HistoryLedgerBlockBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_LCL = 4,
-    VT_RAW_LEDGER = 6
+    VT_BLOCK_BUFFER = 6
   };
   const flatbuffers::Vector<uint8_t> *lcl() const {
     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_LCL);
@@ -1145,63 +1145,63 @@ struct HistoryLedger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   flatbuffers::Vector<uint8_t> *mutable_lcl() {
     return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_LCL);
   }
-  const flatbuffers::Vector<uint8_t> *raw_ledger() const {
-    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_RAW_LEDGER);
+  const flatbuffers::Vector<uint8_t> *block_buffer() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_BLOCK_BUFFER);
   }
-  flatbuffers::Vector<uint8_t> *mutable_raw_ledger() {
-    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_RAW_LEDGER);
+  flatbuffers::Vector<uint8_t> *mutable_block_buffer() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_BLOCK_BUFFER);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_LCL) &&
            verifier.VerifyVector(lcl()) &&
-           VerifyOffset(verifier, VT_RAW_LEDGER) &&
-           verifier.VerifyVector(raw_ledger()) &&
+           VerifyOffset(verifier, VT_BLOCK_BUFFER) &&
+           verifier.VerifyVector(block_buffer()) &&
            verifier.EndTable();
   }
 };
 
-struct HistoryLedgerBuilder {
-  typedef HistoryLedger Table;
+struct HistoryLedgerBlockBuilder {
+  typedef HistoryLedgerBlock Table;
   flatbuffers::FlatBufferBuilder &fbb_;
   flatbuffers::uoffset_t start_;
   void add_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl) {
-    fbb_.AddOffset(HistoryLedger::VT_LCL, lcl);
+    fbb_.AddOffset(HistoryLedgerBlock::VT_LCL, lcl);
   }
-  void add_raw_ledger(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> raw_ledger) {
-    fbb_.AddOffset(HistoryLedger::VT_RAW_LEDGER, raw_ledger);
+  void add_block_buffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> block_buffer) {
+    fbb_.AddOffset(HistoryLedgerBlock::VT_BLOCK_BUFFER, block_buffer);
   }
-  explicit HistoryLedgerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit HistoryLedgerBlockBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  flatbuffers::Offset<HistoryLedger> Finish() {
+  flatbuffers::Offset<HistoryLedgerBlock> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<HistoryLedger>(end);
+    auto o = flatbuffers::Offset<HistoryLedgerBlock>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<HistoryLedger> CreateHistoryLedger(
+inline flatbuffers::Offset<HistoryLedgerBlock> CreateHistoryLedgerBlock(
     flatbuffers::FlatBufferBuilder &_fbb,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl = 0,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> raw_ledger = 0) {
-  HistoryLedgerBuilder builder_(_fbb);
-  builder_.add_raw_ledger(raw_ledger);
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> block_buffer = 0) {
+  HistoryLedgerBlockBuilder builder_(_fbb);
+  builder_.add_block_buffer(block_buffer);
   builder_.add_lcl(lcl);
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<HistoryLedger> CreateHistoryLedgerDirect(
+inline flatbuffers::Offset<HistoryLedgerBlock> CreateHistoryLedgerBlockDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
     const std::vector<uint8_t> *lcl = nullptr,
-    const std::vector<uint8_t> *raw_ledger = nullptr) {
+    const std::vector<uint8_t> *block_buffer = nullptr) {
   auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
-  auto raw_ledger__ = raw_ledger ? _fbb.CreateVector<uint8_t>(*raw_ledger) : 0;
-  return msg::fbuf::p2pmsg::CreateHistoryLedger(
+  auto block_buffer__ = block_buffer ? _fbb.CreateVector<uint8_t>(*block_buffer) : 0;
+  return msg::fbuf::p2pmsg::CreateHistoryLedgerBlock(
       _fbb,
       lcl__,
-      raw_ledger__);
+      block_buffer__);
 }
 
 struct State_Request_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {

src/msg/fbuf/p2pmsg_helpers.cpp

@@ -203,8 +203,8 @@ namespace msg::fbuf::p2pmsg
         if (msg.requester_lcl())
             hr.requester_lcl = flatbuff_bytes_to_sv(msg.requester_lcl());
 
-        if (msg.hist_ledgers())
-            hr.hist_ledgers = flatbuf_historyledgermap_to_historyledgermap(msg.hist_ledgers());
+        if (msg.hist_ledger_blocks())
+            hr.hist_ledger_blocks = flatbuf_historyledgermap_to_historyledgermap(msg.hist_ledger_blocks());
 
         if (msg.error())
             hr.error = (p2p::LEDGER_RESPONSE_ERROR)msg.error();
@@ -430,7 +430,7 @@ namespace msg::fbuf::p2pmsg
             CreateHistory_Response_Message(
                 builder,
                 sv_to_flatbuff_bytes(builder, hr.requester_lcl),
-                historyledgermap_to_flatbuf_historyledgermap(builder, hr.hist_ledgers),
+                historyledgermap_to_flatbuf_historyledgermap(builder, hr.hist_ledger_blocks),
                 (Ledger_Response_Error)hr.error);
 
         flatbuffers::Offset<Content> message = CreateContent(builder, Message_History_Response_Message, hrmsg.Union());
@@ -688,39 +688,39 @@ namespace msg::fbuf::p2pmsg
         return builder.CreateVector(fbvec);
     }
 
-    const std::map<uint64_t, const p2p::history_ledger>
-    flatbuf_historyledgermap_to_historyledgermap(const flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>> *fbvec)
+    const std::map<uint64_t, const p2p::history_ledger_block>
+    flatbuf_historyledgermap_to_historyledgermap(const flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerBlockPair>> *fbvec)
     {
-        std::map<uint64_t, const p2p::history_ledger> map;
+        std::map<uint64_t, const p2p::history_ledger_block> map;
 
-        for (const HistoryLedgerPair *pair : *fbvec)
+        for (const HistoryLedgerBlockPair *pair : *fbvec)
         {
             std::list<usr::user_input> msglist;
 
-            p2p::history_ledger ledger;
+            p2p::history_ledger_block ledger;
 
             ledger.lcl = flatbuff_bytes_to_sv(pair->ledger()->lcl());
-            auto raw = pair->ledger()->raw_ledger();
-            ledger.raw_ledger = std::vector<uint8_t>(raw->begin(), raw->end());
+            auto raw = pair->ledger()->block_buffer();
+            ledger.block_buffer = std::vector<uint8_t>(raw->begin(), raw->end());
 
             map.emplace(pair->seq_no(), std::move(ledger));
         }
         return map;
     }
 
-    const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>>>
-    historyledgermap_to_flatbuf_historyledgermap(flatbuffers::FlatBufferBuilder &builder, const std::map<uint64_t, const p2p::history_ledger> &map)
+    const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerBlockPair>>>
+    historyledgermap_to_flatbuf_historyledgermap(flatbuffers::FlatBufferBuilder &builder, const std::map<uint64_t, const p2p::history_ledger_block> &map)
     {
-        std::vector<flatbuffers::Offset<HistoryLedgerPair>> fbvec;
+        std::vector<flatbuffers::Offset<HistoryLedgerBlockPair>> fbvec;
         fbvec.reserve(map.size());
         for (auto const &[seq_no, ledger] : map)
         {
-            flatbuffers::Offset<HistoryLedger> history_ledger = CreateHistoryLedger(
+            flatbuffers::Offset<HistoryLedgerBlock> history_ledger = CreateHistoryLedgerBlock(
                 builder,
                 sv_to_flatbuff_bytes(builder, ledger.lcl),
-                builder.CreateVector(ledger.raw_ledger));
+                builder.CreateVector(ledger.block_buffer));
 
-            fbvec.push_back(CreateHistoryLedgerPair(
+            fbvec.push_back(CreateHistoryLedgerBlockPair(
                 builder,
                 seq_no,
                 history_ledger));

src/msg/fbuf/p2pmsg_helpers.hpp

@@ -78,11 +78,11 @@ namespace msg::fbuf::p2pmsg
     const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<UserInputGroup>>>
     user_input_map_to_flatbuf_user_input_group(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map<std::string, std::list<usr::user_input>> &map);
 
-    const std::map<uint64_t, const p2p::history_ledger>
-    flatbuf_historyledgermap_to_historyledgermap(const flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>> *fbvec);
+    const std::map<uint64_t, const p2p::history_ledger_block>
+    flatbuf_historyledgermap_to_historyledgermap(const flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerBlockPair>> *fbvec);
 
-    const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>>>
-    historyledgermap_to_flatbuf_historyledgermap(flatbuffers::FlatBufferBuilder &builder, const std::map<uint64_t, const p2p::history_ledger> &map);
+    const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerBlockPair>>>
+    historyledgermap_to_flatbuf_historyledgermap(flatbuffers::FlatBufferBuilder &builder, const std::map<uint64_t, const p2p::history_ledger_block> &map);
 
     void flatbuf_statefshashentry_to_statefshashentry(std::unordered_map<std::string, p2p::state_fs_hash_entry> &fs_entries,
                                                       const flatbuffers::Vector<flatbuffers::Offset<State_FS_Hash_Entry>> *fhashes);