LCL history request and response. (#59)

Detect and request missing lcl history from another random node. Sending lcl history response to a asked node. Getting lcl history response and applying it. Delete lcl that exceeds max ledger sequence.
2026-04-29 15:37:59 +00:00 · 2019-11-19 07:50:33 -05:00
parent 0439ec93e2
commit 95683035b9
18 changed files with 1006 additions and 98 deletions
--- a/src/fbschema/ledger_helpers.cpp
+++ b/src/fbschema/ledger_helpers.cpp
@@ -12,16 +12,17 @@ namespace fbschema::ledger
 * Create ledger from the given proposal struct.
 * @param p The proposal struct to be placed in ledger.
 */
-std::string_view create_ledger_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p)
+std::string_view create_ledger_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p, const uint64_t seq_no)
 {
    flatbuffers::Offset<ledger::Ledger> ledger =
        ledger::CreateLedger(
            builder,
+            seq_no,
            p.time,
            sv_to_flatbuff_bytes(builder, p.lcl),
-            stringlist_to_flatbuf_bytearrayvector(builder, p.users), 0, 0
-            //p2p::hashbuffermap_to_flatbuf_rawinputs(builder, p.raw_inputs),
-            //stringlist_to_flatbuf_bytearrayvector(builder, p.hash_outputs)
+            stringlist_to_flatbuf_bytearrayvector(builder, p.users),
+            stringlist_to_flatbuf_bytearrayvector(builder, p.hash_inputs),
+            stringlist_to_flatbuf_bytearrayvector(builder, p.hash_outputs)
        );

    builder.Finish(ledger); // Finished building message content to get serialised content.
--- a/src/fbschema/ledger_helpers.hpp
+++ b/src/fbschema/ledger_helpers.hpp
@@ -9,7 +9,7 @@
 namespace fbschema::ledger
 {

-std::string_view create_ledger_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p);
+std::string_view create_ledger_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p, const uint64_t seq_no);
 }

 #endif
--- a/src/fbschema/ledger_schema.fbs
+++ b/src/fbschema/ledger_schema.fbs
@@ -3,10 +3,11 @@ include "common_schema.fbs";
 namespace fbschema.ledger;

 table Ledger {
+    seq_no:uint64;
    time:uint64;
    lcl:[ubyte];
    users: [ByteArray];
-    inputs: [RawInputList]; 
+    inputs: [ByteArray]; 
    outputs: [ByteArray];
 }

--- a/src/fbschema/ledger_schema_generated.h
+++ b/src/fbschema/ledger_schema_generated.h
@@ -1,8 +1,8 @@
 // automatically generated by the FlatBuffers compiler, do not modify


-#ifndef FLATBUFFERS_GENERATED_LEDGERSCHEMA_FBSCHEMA_LEDGER_
-#define FLATBUFFERS_GENERATED_LEDGERSCHEMA_FBSCHEMA_LEDGER_
+#ifndef FLATBUFFERS_GENERATED_LEDGERSCHEMA_FBSCHEMA_LEDGER_H_
+#define FLATBUFFERS_GENERATED_LEDGERSCHEMA_FBSCHEMA_LEDGER_H_

 #include "flatbuffers/flatbuffers.h"

@@ -17,12 +17,19 @@ struct RawInputList;

 struct Ledger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_TIME = 4,
-    VT_LCL = 6,
-    VT_USERS = 8,
-    VT_INPUTS = 10,
-    VT_OUTPUTS = 12
+    VT_SEQ_NO = 4,
+    VT_TIME = 6,
+    VT_LCL = 8,
+    VT_USERS = 10,
+    VT_INPUTS = 12,
+    VT_OUTPUTS = 14
  };
+  uint64_t seq_no() const {
+    return GetField<uint64_t>(VT_SEQ_NO, 0);
+  }
+  bool mutate_seq_no(uint64_t _seq_no) {
+    return SetField<uint64_t>(VT_SEQ_NO, _seq_no, 0);
+  }
  uint64_t time() const {
    return GetField<uint64_t>(VT_TIME, 0);
  }
@@ -41,11 +48,11 @@ struct Ledger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *mutable_users() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_USERS);
  }
-  const flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *inputs() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *>(VT_INPUTS);
+  const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *inputs() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_INPUTS);
  }
-  flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *mutable_inputs() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *>(VT_INPUTS);
+  flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *mutable_inputs() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_INPUTS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *outputs() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_OUTPUTS);
@@ -55,6 +62,7 @@ struct Ledger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
+           VerifyField<uint64_t>(verifier, VT_SEQ_NO) &&
           VerifyField<uint64_t>(verifier, VT_TIME) &&
           VerifyOffset(verifier, VT_LCL) &&
           verifier.VerifyVector(lcl()) &&
@@ -74,6 +82,9 @@ struct Ledger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 struct LedgerBuilder {
  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);
+  }
  void add_time(uint64_t time) {
    fbb_.AddElement<uint64_t>(Ledger::VT_TIME, time, 0);
  }
@@ -83,7 +94,7 @@ struct LedgerBuilder {
  void add_users(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> users) {
    fbb_.AddOffset(Ledger::VT_USERS, users);
  }
-  void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawInputList>>> inputs) {
+  void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> inputs) {
    fbb_.AddOffset(Ledger::VT_INPUTS, inputs);
  }
  void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> outputs) {
@@ -103,13 +114,15 @@ struct LedgerBuilder {

 inline flatbuffers::Offset<Ledger> CreateLedger(
    flatbuffers::FlatBufferBuilder &_fbb,
+    uint64_t seq_no = 0,
    uint64_t time = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> users = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawInputList>>> inputs = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> inputs = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> outputs = 0) {
  LedgerBuilder builder_(_fbb);
  builder_.add_time(time);
+  builder_.add_seq_no(seq_no);
  builder_.add_outputs(outputs);
  builder_.add_inputs(inputs);
  builder_.add_users(users);
@@ -119,17 +132,19 @@ inline flatbuffers::Offset<Ledger> CreateLedger(

 inline flatbuffers::Offset<Ledger> CreateLedgerDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
+    uint64_t seq_no = 0,
    uint64_t time = 0,
    const std::vector<uint8_t> *lcl = nullptr,
    const std::vector<flatbuffers::Offset<fbschema::ByteArray>> *users = nullptr,
-    const std::vector<flatbuffers::Offset<RawInputList>> *inputs = nullptr,
+    const std::vector<flatbuffers::Offset<fbschema::ByteArray>> *inputs = nullptr,
    const std::vector<flatbuffers::Offset<fbschema::ByteArray>> *outputs = nullptr) {
  auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
  auto users__ = users ? _fbb.CreateVector<flatbuffers::Offset<fbschema::ByteArray>>(*users) : 0;
-  auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<RawInputList>>(*inputs) : 0;
+  auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<fbschema::ByteArray>>(*inputs) : 0;
  auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<fbschema::ByteArray>>(*outputs) : 0;
  return fbschema::ledger::CreateLedger(
      _fbb,
+      seq_no,
      time,
      lcl__,
      users__,
@@ -245,4 +260,4 @@ inline void FinishSizePrefixedLedgerBuffer(
 }  // namespace ledger
 }  // namespace fbschema

-#endif  // FLATBUFFERS_GENERATED_LEDGERSCHEMA_FBSCHEMA_LEDGER_
+#endif  // FLATBUFFERS_GENERATED_LEDGERSCHEMA_FBSCHEMA_LEDGER_H_
--- a/src/fbschema/p2pmsg_content.fbs
+++ b/src/fbschema/p2pmsg_content.fbs
@@ -12,7 +12,7 @@ table UserSubmittedMessageGroup {
    messages:[UserSubmittedMessage];
 }

-union Message { NonUnl_Proposal_Message, Proposal_Message, Npl_Message } //message content type
+union Message { NonUnl_Proposal_Message, Proposal_Message, Npl_Message, History_Request_Message, History_Response_Message } //message content type

 table Content {
    message:Message;
@@ -35,6 +35,25 @@ table Npl_Message { //NPL type message schema
    data:[ubyte];
 }

+table History_Request_Message { //Ledger History request type message schema
+    minimum_lcl:[ubyte];
+    required_lcl:[ubyte];
+}
+
+table History_Response_Message { //Ledger History request type message schema
+    hist_ledgers:[HistoryLedgerPair];
+}
+
+table HistoryLedgerPair { //A key, value pair of byte[].
+    seq_no:uint64;
+    ledger:HistoryLedger;
+}
+
+table HistoryLedger {
+   lcl:[ubyte];
+   raw_ledger:[ubyte];
+}
+
 table StateDifference { //Represent state difference by tracking created,updated and deleted state files.
    created: [BytesKeyValuePair]; //list of { fn => hash }
    updated: [BytesKeyValuePair]; 
--- a/src/fbschema/p2pmsg_content_generated.h
+++ b/src/fbschema/p2pmsg_content_generated.h
@@ -23,6 +23,14 @@ struct Proposal_Message;

 struct Npl_Message;

+struct History_Request_Message;
+
+struct History_Response_Message;
+
+struct HistoryLedgerPair;
+
+struct HistoryLedger;
+
 struct StateDifference;

 struct State;
@@ -32,16 +40,20 @@ enum Message {
  Message_NonUnl_Proposal_Message = 1,
  Message_Proposal_Message = 2,
  Message_Npl_Message = 3,
+  Message_History_Request_Message = 4,
+  Message_History_Response_Message = 5,
  Message_MIN = Message_NONE,
-  Message_MAX = Message_Npl_Message
+  Message_MAX = Message_History_Response_Message
 };

-inline const Message (&EnumValuesMessage())[4] {
+inline const Message (&EnumValuesMessage())[6] {
  static const Message values[] = {
    Message_NONE,
    Message_NonUnl_Proposal_Message,
    Message_Proposal_Message,
-    Message_Npl_Message
+    Message_Npl_Message,
+    Message_History_Request_Message,
+    Message_History_Response_Message
  };
  return values;
 }
@@ -52,13 +64,15 @@ inline const char * const *EnumNamesMessage() {
    "NonUnl_Proposal_Message",
    "Proposal_Message",
    "Npl_Message",
+    "History_Request_Message",
+    "History_Response_Message",
    nullptr
  };
  return names;
 }

 inline const char *EnumNameMessage(Message e) {
-  if (e < Message_NONE || e > Message_Npl_Message) return "";
+  if (e < Message_NONE || e > Message_History_Response_Message) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMessage()[index];
 }
@@ -79,6 +93,14 @@ template<> struct MessageTraits<Npl_Message> {
  static const Message enum_value = Message_Npl_Message;
 };

+template<> struct MessageTraits<History_Request_Message> {
+  static const Message enum_value = Message_History_Request_Message;
+};
+
+template<> struct MessageTraits<History_Response_Message> {
+  static const Message enum_value = Message_History_Response_Message;
+};
+
 bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Message type);
 bool VerifyMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);

@@ -247,6 +269,12 @@ struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const Npl_Message *message_as_Npl_Message() const {
    return message_type() == Message_Npl_Message ? static_cast<const Npl_Message *>(message()) : nullptr;
  }
+  const History_Request_Message *message_as_History_Request_Message() const {
+    return message_type() == Message_History_Request_Message ? static_cast<const History_Request_Message *>(message()) : nullptr;
+  }
+  const History_Response_Message *message_as_History_Response_Message() const {
+    return message_type() == Message_History_Response_Message ? static_cast<const History_Response_Message *>(message()) : nullptr;
+  }
  void *mutable_message() {
    return GetPointer<void *>(VT_MESSAGE);
  }
@@ -271,6 +299,14 @@ template<> inline const Npl_Message *Content::message_as<Npl_Message>() const {
  return message_as_Npl_Message();
 }

+template<> inline const History_Request_Message *Content::message_as<History_Request_Message>() const {
+  return message_as_History_Request_Message();
+}
+
+template<> inline const History_Response_Message *Content::message_as<History_Response_Message>() const {
+  return message_as_History_Response_Message();
+}
+
 struct ContentBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
@@ -545,6 +581,257 @@ inline flatbuffers::Offset<Npl_Message> CreateNpl_MessageDirect(
      data__);
 }

+struct History_Request_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_MINIMUM_LCL = 4,
+    VT_REQUIRED_LCL = 6
+  };
+  const flatbuffers::Vector<uint8_t> *minimum_lcl() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MINIMUM_LCL);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_minimum_lcl() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_MINIMUM_LCL);
+  }
+  const flatbuffers::Vector<uint8_t> *required_lcl() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_REQUIRED_LCL);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_required_lcl() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_REQUIRED_LCL);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_MINIMUM_LCL) &&
+           verifier.VerifyVector(minimum_lcl()) &&
+           VerifyOffset(verifier, VT_REQUIRED_LCL) &&
+           verifier.VerifyVector(required_lcl()) &&
+           verifier.EndTable();
+  }
+};
+
+struct History_Request_MessageBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_minimum_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> minimum_lcl) {
+    fbb_.AddOffset(History_Request_Message::VT_MINIMUM_LCL, minimum_lcl);
+  }
+  void add_required_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> required_lcl) {
+    fbb_.AddOffset(History_Request_Message::VT_REQUIRED_LCL, required_lcl);
+  }
+  explicit History_Request_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  History_Request_MessageBuilder &operator=(const History_Request_MessageBuilder &);
+  flatbuffers::Offset<History_Request_Message> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<History_Request_Message>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<History_Request_Message> CreateHistory_Request_Message(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> minimum_lcl = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> required_lcl = 0) {
+  History_Request_MessageBuilder builder_(_fbb);
+  builder_.add_required_lcl(required_lcl);
+  builder_.add_minimum_lcl(minimum_lcl);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<History_Request_Message> CreateHistory_Request_MessageDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<uint8_t> *minimum_lcl = nullptr,
+    const std::vector<uint8_t> *required_lcl = nullptr) {
+  auto minimum_lcl__ = minimum_lcl ? _fbb.CreateVector<uint8_t>(*minimum_lcl) : 0;
+  auto required_lcl__ = required_lcl ? _fbb.CreateVector<uint8_t>(*required_lcl) : 0;
+  return fbschema::p2pmsg::CreateHistory_Request_Message(
+      _fbb,
+      minimum_lcl__,
+      required_lcl__);
+}
+
+struct History_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_HIST_LEDGERS = 4
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>> *hist_ledgers() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>> *>(VT_HIST_LEDGERS);
+  }
+  flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>> *mutable_hist_ledgers() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>> *>(VT_HIST_LEDGERS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_HIST_LEDGERS) &&
+           verifier.VerifyVector(hist_ledgers()) &&
+           verifier.VerifyVectorOfTables(hist_ledgers()) &&
+           verifier.EndTable();
+  }
+};
+
+struct History_Response_MessageBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_hist_ledgers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>>> hist_ledgers) {
+    fbb_.AddOffset(History_Response_Message::VT_HIST_LEDGERS, hist_ledgers);
+  }
+  explicit History_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  History_Response_MessageBuilder &operator=(const History_Response_MessageBuilder &);
+  flatbuffers::Offset<History_Response_Message> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<History_Response_Message>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<History_Response_Message> CreateHistory_Response_Message(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>>> hist_ledgers = 0) {
+  History_Response_MessageBuilder builder_(_fbb);
+  builder_.add_hist_ledgers(hist_ledgers);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<History_Response_Message> CreateHistory_Response_MessageDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<HistoryLedgerPair>> *hist_ledgers = nullptr) {
+  auto hist_ledgers__ = hist_ledgers ? _fbb.CreateVector<flatbuffers::Offset<HistoryLedgerPair>>(*hist_ledgers) : 0;
+  return fbschema::p2pmsg::CreateHistory_Response_Message(
+      _fbb,
+      hist_ledgers__);
+}
+
+struct HistoryLedgerPair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_SEQ_NO = 4,
+    VT_LEDGER = 6
+  };
+  uint64_t seq_no() const {
+    return GetField<uint64_t>(VT_SEQ_NO, 0);
+  }
+  bool mutate_seq_no(uint64_t _seq_no) {
+    return SetField<uint64_t>(VT_SEQ_NO, _seq_no, 0);
+  }
+  const HistoryLedger *ledger() const {
+    return GetPointer<const HistoryLedger *>(VT_LEDGER);
+  }
+  HistoryLedger *mutable_ledger() {
+    return GetPointer<HistoryLedger *>(VT_LEDGER);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint64_t>(verifier, VT_SEQ_NO) &&
+           VerifyOffset(verifier, VT_LEDGER) &&
+           verifier.VerifyTable(ledger()) &&
+           verifier.EndTable();
+  }
+};
+
+struct HistoryLedgerPairBuilder {
+  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);
+  }
+  void add_ledger(flatbuffers::Offset<HistoryLedger> ledger) {
+    fbb_.AddOffset(HistoryLedgerPair::VT_LEDGER, ledger);
+  }
+  explicit HistoryLedgerPairBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  HistoryLedgerPairBuilder &operator=(const HistoryLedgerPairBuilder &);
+  flatbuffers::Offset<HistoryLedgerPair> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<HistoryLedgerPair>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<HistoryLedgerPair> CreateHistoryLedgerPair(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    uint64_t seq_no = 0,
+    flatbuffers::Offset<HistoryLedger> ledger = 0) {
+  HistoryLedgerPairBuilder builder_(_fbb);
+  builder_.add_seq_no(seq_no);
+  builder_.add_ledger(ledger);
+  return builder_.Finish();
+}
+
+struct HistoryLedger FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LCL = 4,
+    VT_RAW_LEDGER = 6
+  };
+  const flatbuffers::Vector<uint8_t> *lcl() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_LCL);
+  }
+  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);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_raw_ledger() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_RAW_LEDGER);
+  }
+  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()) &&
+           verifier.EndTable();
+  }
+};
+
+struct HistoryLedgerBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl) {
+    fbb_.AddOffset(HistoryLedger::VT_LCL, lcl);
+  }
+  void add_raw_ledger(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> raw_ledger) {
+    fbb_.AddOffset(HistoryLedger::VT_RAW_LEDGER, raw_ledger);
+  }
+  explicit HistoryLedgerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  HistoryLedgerBuilder &operator=(const HistoryLedgerBuilder &);
+  flatbuffers::Offset<HistoryLedger> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<HistoryLedger>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<HistoryLedger> CreateHistoryLedger(
+    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);
+  builder_.add_lcl(lcl);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<HistoryLedger> CreateHistoryLedgerDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<uint8_t> *lcl = nullptr,
+    const std::vector<uint8_t> *raw_ledger = nullptr) {
+  auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
+  auto raw_ledger__ = raw_ledger ? _fbb.CreateVector<uint8_t>(*raw_ledger) : 0;
+  return fbschema::p2pmsg::CreateHistoryLedger(
+      _fbb,
+      lcl__,
+      raw_ledger__);
+}
+
 struct StateDifference FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CREATED = 4,
@@ -756,6 +1043,14 @@ inline bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Mess
      auto ptr = reinterpret_cast<const Npl_Message *>(obj);
      return verifier.VerifyTable(ptr);
    }
+    case Message_History_Request_Message: {
+      auto ptr = reinterpret_cast<const History_Request_Message *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Message_History_Response_Message: {
+      auto ptr = reinterpret_cast<const History_Response_Message *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
    default: return false;
  }
 }
--- a/src/fbschema/p2pmsg_helpers.cpp
+++ b/src/fbschema/p2pmsg_helpers.cpp
@@ -154,6 +154,21 @@ const p2p::nonunl_proposal create_nonunl_proposal_from_msg(const NonUnl_Proposal
    return nup;
 }

+/**
+ * Creates a history response stuct from the given histrory response message.
+ * @param msg Flatbuffer History response message received from the peer.
+ * @return A History response struct representing the message.
+ */
+const p2p::history_response create_history_response_from_msg(const History_Response_Message &msg)
+{
+    p2p::history_response hr;
+
+    if (msg.hist_ledgers())
+        hr.hist_ledgers = flatbuf_historyledgermap_to_historyledgermap(msg.hist_ledgers());
+
+    return hr;
+}
+
 /**
 * Creates a proposal stuct from the given proposal message.
 * @param The Flatbuffer poporal received from the peer.
@@ -181,6 +196,24 @@ const p2p::proposal create_proposal_from_msg(const Proposal_Message &msg, const
    return p;
 }

+/**
+ * Creates a history request struct from the given history request message.
+ * @param msg Flatbuffer History request message received from the peer.
+ * @return A History request struct representing the message.
+ */
+const p2p::history_request create_history_request_from_msg(const History_Request_Message &msg)
+{
+    p2p::history_request hr;
+
+    if (msg.minimum_lcl())
+        hr.minimum_lcl = flatbuff_bytes_to_sv(msg.minimum_lcl());
+
+    if (msg.required_lcl())
+        hr.required_lcl = flatbuff_bytes_to_sv(msg.required_lcl());
+
+    return hr;
+}
+
 //---Message creation helpers---//

 void create_msg_from_nonunl_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::nonunl_proposal &nup)
@@ -201,7 +234,7 @@ void create_msg_from_nonunl_proposal(flatbuffers::FlatBufferBuilder &container_b
 }

 /**
- * Ctreat proposal peer message from the given proposal struct.
+ * Create proposal peer message from the given proposal struct.
 * @param container_builder Flatbuffer builder for the container message.
 * @param p The proposal struct to be placed in the container message.
 */
@@ -250,6 +283,51 @@ void create_msg_from_npl_output(flatbuffers::FlatBufferBuilder &container_builde
    create_containermsg_from_content(container_builder, builder, lcl, true);
 }

+/**
+ * Create history request message from the given history request struct.
+ * @param container_builder Flatbuffer builder for the container message.
+ * @param hr The History request struct to be placed in the container message.
+ */
+void create_msg_from_history_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::history_request &hr)
+{
+    flatbuffers::FlatBufferBuilder builder(1024);
+
+    flatbuffers::Offset<History_Request_Message> hrmsg =
+        CreateHistory_Request_Message(
+            builder,
+            sv_to_flatbuff_bytes(builder, hr.minimum_lcl),
+            sv_to_flatbuff_bytes(builder, hr.required_lcl));
+
+    flatbuffers::Offset<Content> message = CreateContent(builder, Message_History_Request_Message, hrmsg.Union());
+    builder.Finish(message); // Finished building message content to get serialised content.
+
+    // Now that we have built the content message,
+    // we need to sign it and place it inside a container message.
+    create_containermsg_from_content(container_builder, builder, nullptr, true);
+}
+
+/**
+ * Create history response message from the given history response struct.
+ * @param container_builder Flatbuffer builder for the container message.
+ * @param hr The History response struct to be placed in the container message.
+ */
+void create_msg_from_history_response(flatbuffers::FlatBufferBuilder &container_builder, const p2p::history_response &hr)
+{
+    flatbuffers::FlatBufferBuilder builder(1024);
+
+    flatbuffers::Offset<History_Response_Message> hrmsg =
+        CreateHistory_Response_Message(
+            builder,
+            historyledgermap_to_flatbuf_historyledgermap(builder, hr.hist_ledgers));
+
+    flatbuffers::Offset<Content> message = CreateContent(builder, Message_History_Response_Message, hrmsg.Union());
+    builder.Finish(message); // Finished building message content to get serialised content.
+
+    // Now that we have built the content message,
+    // we need to sign it and place it inside a container message.
+    create_containermsg_from_content(container_builder, builder, nullptr, true);
+}
+
 /**
 * Creates a Flatbuffer container message from the given Content message.
 * @param container_builder The Flatbuffer builder to which the final container message should be written to.
@@ -346,4 +424,44 @@ usermsgsmap_to_flatbuf_usermsgsmap(flatbuffers::FlatBufferBuilder &builder, cons
    return builder.CreateVector(fbvec);
 }

+const std::map<uint64_t, const p2p::history_ledger>
+flatbuf_historyledgermap_to_historyledgermap(const flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>> *fbvec)
+{
+    std::map<uint64_t, const p2p::history_ledger> map;
+
+    for (const HistoryLedgerPair *pair : *fbvec)
+    {
+        std::list<usr::user_submitted_message> msglist;
+
+        p2p::history_ledger 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());
+
+        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)
+{
+    std::vector<flatbuffers::Offset<HistoryLedgerPair>> fbvec;
+    fbvec.reserve(map.size());
+    for (auto const &[seq_no, ledger] : map)
+    {
+        flatbuffers::Offset<HistoryLedger> history_ledger = CreateHistoryLedger(
+            builder,
+            sv_to_flatbuff_bytes(builder, ledger.lcl),
+            builder.CreateVector(ledger.raw_ledger));
+
+        fbvec.push_back(CreateHistoryLedgerPair(
+            builder,
+            seq_no,
+            history_ledger));
+    }
+    return builder.CreateVector(fbvec);
+}
+
 } // namespace fbschema::p2pmsg
--- a/src/fbschema/p2pmsg_helpers.hpp
+++ b/src/fbschema/p2pmsg_helpers.hpp
@@ -25,12 +25,20 @@ const p2p::nonunl_proposal create_nonunl_proposal_from_msg(const NonUnl_Proposal

 const p2p::proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector<uint8_t> *pubkey, const uint64_t timestamp, const flatbuffers::Vector<uint8_t> *lcl);

+const p2p::history_request create_history_request_from_msg(const History_Request_Message &msg);
+
+const p2p::history_response create_history_response_from_msg(const History_Response_Message &msg);
+
 //---Message creation helpers---//

 void create_msg_from_nonunl_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::nonunl_proposal &nup);

 void create_msg_from_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::proposal &p);

+void create_msg_from_history_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::history_request &hr);
+
+void create_msg_from_history_response(flatbuffers::FlatBufferBuilder &container_builder, const p2p::history_response &hr);
+
 void create_msg_from_npl_output(flatbuffers::FlatBufferBuilder &container_builder, const p2p::npl_message &npl, std::string_view lcl);

 void create_containermsg_from_content(
@@ -46,6 +54,12 @@ flatbuf_usermsgsmap_to_usermsgsmap(const flatbuffers::Vector<flatbuffers::Offset
 const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<UserSubmittedMessageGroup>>>
 usermsgsmap_to_flatbuf_usermsgsmap(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map<std::string, const std::list<usr::user_submitted_message>> &map);

+const std::map<uint64_t, const p2p::history_ledger>
+flatbuf_historyledgermap_to_historyledgermap(const flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerPair>> *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);
+
 } // namespace fbschema::p2pmsg

 #endif