Subject unl list to consensus. (#186)

* Unl hash in consensus proposals.
* Unl syncing and sync request serving.
* Adding unl hash to the ledger block.

src/msg/fbuf/ledger_helpers.cpp

@@ -25,6 +25,7 @@ namespace msg::fbuf::ledger
                 p.time,
                 sv_to_flatbuff_bytes(builder, p.lcl),
                 hash_to_flatbuff_bytes(builder, p.state),
+                sv_to_flatbuff_bytes(builder, p.unl_hash),
                 stringlist_to_flatbuf_bytearrayvector(builder, p.users),
                 stringlist_to_flatbuf_bytearrayvector(builder, p.hash_inputs),
                 stringlist_to_flatbuf_bytearrayvector(builder, p.hash_outputs),

src/msg/fbuf/ledger_schema.fbs

@@ -7,6 +7,7 @@ table LedgerBlock {
     time:uint64;
     lcl:[ubyte];
     state:[ubyte];
+    unl:[ubyte];
     users: [ByteArray];
     inputs: [ByteArray]; 
     outputs: [ByteArray];

src/msg/fbuf/ledger_schema_generated.h

@@ -25,10 +25,11 @@ struct LedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_TIME = 6,
     VT_LCL = 8,
     VT_STATE = 10,
-    VT_USERS = 12,
-    VT_INPUTS = 14,
-    VT_OUTPUTS = 16,
-    VT_UNL_CHANGESET = 18
+    VT_UNL = 12,
+    VT_USERS = 14,
+    VT_INPUTS = 16,
+    VT_OUTPUTS = 18,
+    VT_UNL_CHANGESET = 20
   };
   uint64_t seq_no() const {
     return GetField<uint64_t>(VT_SEQ_NO, 0);
@@ -54,6 +55,12 @@ struct LedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   flatbuffers::Vector<uint8_t> *mutable_state() {
     return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_STATE);
   }
+  const flatbuffers::Vector<uint8_t> *unl() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_UNL);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_unl() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_UNL);
+  }
   const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *users() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_USERS);
   }
@@ -86,6 +93,8 @@ struct LedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            verifier.VerifyVector(lcl()) &&
            VerifyOffset(verifier, VT_STATE) &&
            verifier.VerifyVector(state()) &&
+           VerifyOffset(verifier, VT_UNL) &&
+           verifier.VerifyVector(unl()) &&
            VerifyOffset(verifier, VT_USERS) &&
            verifier.VerifyVector(users()) &&
            verifier.VerifyVectorOfTables(users()) &&
@@ -117,6 +126,9 @@ struct LedgerBlockBuilder {
   void add_state(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> state) {
     fbb_.AddOffset(LedgerBlock::VT_STATE, state);
   }
+  void add_unl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> unl) {
+    fbb_.AddOffset(LedgerBlock::VT_UNL, unl);
+  }
   void add_users(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> users) {
     fbb_.AddOffset(LedgerBlock::VT_USERS, users);
   }
@@ -146,6 +158,7 @@ inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlock(
     uint64_t time = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> state = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> unl = 0,
     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,
@@ -157,6 +170,7 @@ inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlock(
   builder_.add_outputs(outputs);
   builder_.add_inputs(inputs);
   builder_.add_users(users);
+  builder_.add_unl(unl);
   builder_.add_state(state);
   builder_.add_lcl(lcl);
   return builder_.Finish();
@@ -168,12 +182,14 @@ inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlockDirect(
     uint64_t time = 0,
     const std::vector<uint8_t> *lcl = nullptr,
     const std::vector<uint8_t> *state = nullptr,
+    const std::vector<uint8_t> *unl = nullptr,
     const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *users = nullptr,
     const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *inputs = nullptr,
     const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *outputs = nullptr,
     flatbuffers::Offset<msg::fbuf::ledger::Unl_Changeset> unl_changeset = 0) {
   auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
   auto state__ = state ? _fbb.CreateVector<uint8_t>(*state) : 0;
+  auto unl__ = unl ? _fbb.CreateVector<uint8_t>(*unl) : 0;
   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;
@@ -183,6 +199,7 @@ inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlockDirect(
       time,
       lcl__,
       state__,
+      unl__,
       users__,
       inputs__,
       outputs__,

src/msg/fbuf/p2pmsg_content.fbs

@@ -38,7 +38,9 @@ union Message {
     Peer_Requirement_Announcement_Message,
     Peer_List_Request_Message,
     Peer_List_Response_Message,
-    Available_Capacity_Announcement_Message
+    Available_Capacity_Announcement_Message,
+    Unl_Request_Message,
+    Unl_Response_Message
 } //message content type
 
 table Content {
@@ -62,6 +64,7 @@ table Proposal_Message { //Proposal type message schema
     hash_inputs:[ByteArray];
     hash_outputs:[ByteArray];
     state: [ubyte];
+    unl_hash: [ubyte]; // Hash of the current unl list.
     unl_changeset: Unl_Changeset;
 }
 
@@ -73,6 +76,15 @@ table History_Request_Message { //Ledger History request type message schema
     required_lcl:[ubyte];
 }
 
+table Unl_Request_Message {
+    required_unl: [ubyte];
+}
+
+table Unl_Response_Message {
+    requester_unl:[ubyte]; // Unl hash of the sender.
+    unl_list: [ByteArray];
+}
+
 enum Ledger_Response_Error : ubyte
 {
     None = 0,

src/msg/fbuf/p2pmsg_content_generated.h

@@ -42,6 +42,12 @@ struct Npl_MessageBuilder;
 struct History_Request_Message;
 struct History_Request_MessageBuilder;
 
+struct Unl_Request_Message;
+struct Unl_Request_MessageBuilder;
+
+struct Unl_Response_Message;
+struct Unl_Response_MessageBuilder;
+
 struct History_Response_Message;
 struct History_Response_MessageBuilder;
 
@@ -99,11 +105,13 @@ enum Message {
   Message_Peer_List_Request_Message = 11,
   Message_Peer_List_Response_Message = 12,
   Message_Available_Capacity_Announcement_Message = 13,
+  Message_Unl_Request_Message = 14,
+  Message_Unl_Response_Message = 15,
   Message_MIN = Message_NONE,
-  Message_MAX = Message_Available_Capacity_Announcement_Message
+  Message_MAX = Message_Unl_Response_Message
 };
 
-inline const Message (&EnumValuesMessage())[14] {
+inline const Message (&EnumValuesMessage())[16] {
   static const Message values[] = {
     Message_NONE,
     Message_Peer_Challenge_Response_Message,
@@ -118,13 +126,15 @@ inline const Message (&EnumValuesMessage())[14] {
     Message_Peer_Requirement_Announcement_Message,
     Message_Peer_List_Request_Message,
     Message_Peer_List_Response_Message,
-    Message_Available_Capacity_Announcement_Message
+    Message_Available_Capacity_Announcement_Message,
+    Message_Unl_Request_Message,
+    Message_Unl_Response_Message
   };
   return values;
 }
 
 inline const char * const *EnumNamesMessage() {
-  static const char * const names[15] = {
+  static const char * const names[17] = {
     "NONE",
     "Peer_Challenge_Response_Message",
     "Peer_Challenge_Message",
@@ -139,13 +149,15 @@ inline const char * const *EnumNamesMessage() {
     "Peer_List_Request_Message",
     "Peer_List_Response_Message",
     "Available_Capacity_Announcement_Message",
+    "Unl_Request_Message",
+    "Unl_Response_Message",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameMessage(Message e) {
-  if (flatbuffers::IsOutRange(e, Message_NONE, Message_Available_Capacity_Announcement_Message)) return "";
+  if (flatbuffers::IsOutRange(e, Message_NONE, Message_Unl_Response_Message)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesMessage()[index];
 }
@@ -206,6 +218,14 @@ template<> struct MessageTraits<msg::fbuf::p2pmsg::Available_Capacity_Announceme
   static const Message enum_value = Message_Available_Capacity_Announcement_Message;
 };
 
+template<> struct MessageTraits<msg::fbuf::p2pmsg::Unl_Request_Message> {
+  static const Message enum_value = Message_Unl_Request_Message;
+};
+
+template<> struct MessageTraits<msg::fbuf::p2pmsg::Unl_Response_Message> {
+  static const Message enum_value = Message_Unl_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);
 
@@ -649,6 +669,12 @@ struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const msg::fbuf::p2pmsg::Available_Capacity_Announcement_Message *message_as_Available_Capacity_Announcement_Message() const {
     return message_type() == msg::fbuf::p2pmsg::Message_Available_Capacity_Announcement_Message ? static_cast<const msg::fbuf::p2pmsg::Available_Capacity_Announcement_Message *>(message()) : nullptr;
   }
+  const msg::fbuf::p2pmsg::Unl_Request_Message *message_as_Unl_Request_Message() const {
+    return message_type() == msg::fbuf::p2pmsg::Message_Unl_Request_Message ? static_cast<const msg::fbuf::p2pmsg::Unl_Request_Message *>(message()) : nullptr;
+  }
+  const msg::fbuf::p2pmsg::Unl_Response_Message *message_as_Unl_Response_Message() const {
+    return message_type() == msg::fbuf::p2pmsg::Message_Unl_Response_Message ? static_cast<const msg::fbuf::p2pmsg::Unl_Response_Message *>(message()) : nullptr;
+  }
   void *mutable_message() {
     return GetPointer<void *>(VT_MESSAGE);
   }
@@ -713,6 +739,14 @@ template<> inline const msg::fbuf::p2pmsg::Available_Capacity_Announcement_Messa
   return message_as_Available_Capacity_Announcement_Message();
 }
 
+template<> inline const msg::fbuf::p2pmsg::Unl_Request_Message *Content::message_as<msg::fbuf::p2pmsg::Unl_Request_Message>() const {
+  return message_as_Unl_Request_Message();
+}
+
+template<> inline const msg::fbuf::p2pmsg::Unl_Response_Message *Content::message_as<msg::fbuf::p2pmsg::Unl_Response_Message>() const {
+  return message_as_Unl_Response_Message();
+}
+
 struct ContentBuilder {
   typedef Content Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -882,7 +916,8 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_HASH_INPUTS = 12,
     VT_HASH_OUTPUTS = 14,
     VT_STATE = 16,
-    VT_UNL_CHANGESET = 18
+    VT_UNL_HASH = 18,
+    VT_UNL_CHANGESET = 20
   };
   uint8_t stage() const {
     return GetField<uint8_t>(VT_STAGE, 0);
@@ -926,6 +961,12 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   flatbuffers::Vector<uint8_t> *mutable_state() {
     return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_STATE);
   }
+  const flatbuffers::Vector<uint8_t> *unl_hash() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_UNL_HASH);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_unl_hash() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_UNL_HASH);
+  }
   const msg::fbuf::p2pmsg::Unl_Changeset *unl_changeset() const {
     return GetPointer<const msg::fbuf::p2pmsg::Unl_Changeset *>(VT_UNL_CHANGESET);
   }
@@ -949,6 +990,8 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            verifier.VerifyVectorOfTables(hash_outputs()) &&
            VerifyOffset(verifier, VT_STATE) &&
            verifier.VerifyVector(state()) &&
+           VerifyOffset(verifier, VT_UNL_HASH) &&
+           verifier.VerifyVector(unl_hash()) &&
            VerifyOffset(verifier, VT_UNL_CHANGESET) &&
            verifier.VerifyTable(unl_changeset()) &&
            verifier.EndTable();
@@ -980,6 +1023,9 @@ struct Proposal_MessageBuilder {
   void add_state(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> state) {
     fbb_.AddOffset(Proposal_Message::VT_STATE, state);
   }
+  void add_unl_hash(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> unl_hash) {
+    fbb_.AddOffset(Proposal_Message::VT_UNL_HASH, unl_hash);
+  }
   void add_unl_changeset(flatbuffers::Offset<msg::fbuf::p2pmsg::Unl_Changeset> unl_changeset) {
     fbb_.AddOffset(Proposal_Message::VT_UNL_CHANGESET, unl_changeset);
   }
@@ -1003,10 +1049,12 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_Message(
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> hash_inputs = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> hash_outputs = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> state = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> unl_hash = 0,
     flatbuffers::Offset<msg::fbuf::p2pmsg::Unl_Changeset> unl_changeset = 0) {
   Proposal_MessageBuilder builder_(_fbb);
   builder_.add_time(time);
   builder_.add_unl_changeset(unl_changeset);
+  builder_.add_unl_hash(unl_hash);
   builder_.add_state(state);
   builder_.add_hash_outputs(hash_outputs);
   builder_.add_hash_inputs(hash_inputs);
@@ -1025,12 +1073,14 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_MessageDirect(
     const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *hash_inputs = nullptr,
     const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *hash_outputs = nullptr,
     const std::vector<uint8_t> *state = nullptr,
+    const std::vector<uint8_t> *unl_hash = nullptr,
     flatbuffers::Offset<msg::fbuf::p2pmsg::Unl_Changeset> unl_changeset = 0) {
   auto nonce__ = nonce ? _fbb.CreateVector<uint8_t>(*nonce) : 0;
   auto users__ = users ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*users) : 0;
   auto hash_inputs__ = hash_inputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*hash_inputs) : 0;
   auto hash_outputs__ = hash_outputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*hash_outputs) : 0;
   auto state__ = state ? _fbb.CreateVector<uint8_t>(*state) : 0;
+  auto unl_hash__ = unl_hash ? _fbb.CreateVector<uint8_t>(*unl_hash) : 0;
   return msg::fbuf::p2pmsg::CreateProposal_Message(
       _fbb,
       stage,
@@ -1040,6 +1090,7 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_MessageDirect(
       hash_inputs__,
       hash_outputs__,
       state__,
+      unl_hash__,
       unl_changeset);
 }
 
@@ -1151,6 +1202,132 @@ inline flatbuffers::Offset<History_Request_Message> CreateHistory_Request_Messag
       required_lcl__);
 }
 
+struct Unl_Request_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef Unl_Request_MessageBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_REQUIRED_UNL = 4
+  };
+  const flatbuffers::Vector<uint8_t> *required_unl() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_REQUIRED_UNL);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_required_unl() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_REQUIRED_UNL);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_REQUIRED_UNL) &&
+           verifier.VerifyVector(required_unl()) &&
+           verifier.EndTable();
+  }
+};
+
+struct Unl_Request_MessageBuilder {
+  typedef Unl_Request_Message Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_required_unl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> required_unl) {
+    fbb_.AddOffset(Unl_Request_Message::VT_REQUIRED_UNL, required_unl);
+  }
+  explicit Unl_Request_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<Unl_Request_Message> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Unl_Request_Message>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Unl_Request_Message> CreateUnl_Request_Message(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> required_unl = 0) {
+  Unl_Request_MessageBuilder builder_(_fbb);
+  builder_.add_required_unl(required_unl);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Unl_Request_Message> CreateUnl_Request_MessageDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<uint8_t> *required_unl = nullptr) {
+  auto required_unl__ = required_unl ? _fbb.CreateVector<uint8_t>(*required_unl) : 0;
+  return msg::fbuf::p2pmsg::CreateUnl_Request_Message(
+      _fbb,
+      required_unl__);
+}
+
+struct Unl_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef Unl_Response_MessageBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_REQUESTER_UNL = 4,
+    VT_UNL_LIST = 6
+  };
+  const flatbuffers::Vector<uint8_t> *requester_unl() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_REQUESTER_UNL);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_requester_unl() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_REQUESTER_UNL);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *unl_list() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_UNL_LIST);
+  }
+  flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_unl_list() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_UNL_LIST);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_REQUESTER_UNL) &&
+           verifier.VerifyVector(requester_unl()) &&
+           VerifyOffset(verifier, VT_UNL_LIST) &&
+           verifier.VerifyVector(unl_list()) &&
+           verifier.VerifyVectorOfTables(unl_list()) &&
+           verifier.EndTable();
+  }
+};
+
+struct Unl_Response_MessageBuilder {
+  typedef Unl_Response_Message Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_requester_unl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> requester_unl) {
+    fbb_.AddOffset(Unl_Response_Message::VT_REQUESTER_UNL, requester_unl);
+  }
+  void add_unl_list(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> unl_list) {
+    fbb_.AddOffset(Unl_Response_Message::VT_UNL_LIST, unl_list);
+  }
+  explicit Unl_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<Unl_Response_Message> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Unl_Response_Message>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Unl_Response_Message> CreateUnl_Response_Message(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> requester_unl = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> unl_list = 0) {
+  Unl_Response_MessageBuilder builder_(_fbb);
+  builder_.add_unl_list(unl_list);
+  builder_.add_requester_unl(requester_unl);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Unl_Response_Message> CreateUnl_Response_MessageDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<uint8_t> *requester_unl = nullptr,
+    const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *unl_list = nullptr) {
+  auto requester_unl__ = requester_unl ? _fbb.CreateVector<uint8_t>(*requester_unl) : 0;
+  auto unl_list__ = unl_list ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*unl_list) : 0;
+  return msg::fbuf::p2pmsg::CreateUnl_Response_Message(
+      _fbb,
+      requester_unl__,
+      unl_list__);
+}
+
 struct History_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef History_Response_MessageBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -2209,6 +2386,14 @@ inline bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Mess
       auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Available_Capacity_Announcement_Message *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case Message_Unl_Request_Message: {
+      auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Unl_Request_Message *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Message_Unl_Response_Message: {
+      auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Unl_Response_Message *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return true;
   }
 }

src/msg/fbuf/p2pmsg_helpers.cpp

@@ -230,6 +230,7 @@ namespace msg::fbuf::p2pmsg
         p.nonce = flatbuff_bytes_to_sv(msg.nonce());
         p.stage = msg.stage();
         p.lcl = flatbuff_bytes_to_sv(lcl);
+        p.unl_hash = flatbuff_bytes_to_sv(msg.unl_hash());
         p.state = flatbuff_bytes_to_sv(msg.state());
 
         const auto unl_changeset = msg.unl_changeset();
@@ -388,6 +389,7 @@ namespace msg::fbuf::p2pmsg
                 stringlist_to_flatbuf_bytearrayvector(builder, p.hash_inputs),
                 stringlist_to_flatbuf_bytearrayvector(builder, p.hash_outputs),
                 hash_to_flatbuff_bytes(builder, p.state),
+                sv_to_flatbuff_bytes(builder, p.unl_hash),
                 unl_changeset);
 
         const flatbuffers::Offset<Content> message = CreateContent(builder, Message_Proposal_Message, proposal.Union());
@@ -683,6 +685,79 @@ namespace msg::fbuf::p2pmsg
         create_containermsg_from_content(container_builder, builder, lcl, false);
     }
 
+    /**
+     * Create unl request message from the given unl sync request struct.
+     * @param container_builder Flatbuffer builder for the container message.
+     * @param unl_sync_message The Unl sync request struct to be placed in the container message.
+     */
+    void create_msg_from_unl_sync_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::unl_sync_request &unl_sync_message)
+    {
+        flatbuffers::FlatBufferBuilder builder(1024);
+
+        flatbuffers::Offset<Unl_Request_Message> unl_req_msg =
+            CreateUnl_Request_Message(
+                builder,
+                sv_to_flatbuff_bytes(builder, unl_sync_message.required_unl));
+
+        flatbuffers::Offset<Content> message = CreateContent(builder, Message_Unl_Request_Message, unl_req_msg.Union());
+        builder.Finish(message); // Finished building message content to get serialised content.
+
+        // Now that we have built the content message,
+        // we need to place it inside a container message.
+        create_containermsg_from_content(container_builder, builder, {}, false);
+    }
+
+    /**
+     * Creates a unl sync request struct from the given unl request message.
+     * @param unl_req_message Flatbuffer unl request message received from the peer.
+     * @return A unl sync request struct representing the message.
+     */
+    const p2p::unl_sync_request create_unl_sync_request_from_msg(const Unl_Request_Message &unl_req_message)
+    {
+        p2p::unl_sync_request unl_sync;
+        unl_sync.required_unl = flatbuff_bytes_to_sv(unl_req_message.required_unl());
+
+        return unl_sync;
+    }
+
+    /**
+     * Create unl response message from the given unl sync response struct.
+     * @param container_builder Flatbuffer builder for the container message.
+     * @param unl_response The unl sync response struct to be placed in the container message.
+     */
+    void create_msg_from_unl_sync_response(flatbuffers::FlatBufferBuilder &container_builder, const p2p::unl_sync_response &unl_response)
+    {
+        flatbuffers::FlatBufferBuilder builder(1024);
+
+        flatbuffers::Offset<Unl_Response_Message> unl_res_msg =
+            CreateUnl_Response_Message(
+                builder,
+                sv_to_flatbuff_bytes(builder, unl_response.requester_unl),
+                stringlist_to_flatbuf_bytearrayvector(builder, unl_response.unl_list));
+
+        flatbuffers::Offset<Content> message = CreateContent(builder, Message_Unl_Response_Message, unl_res_msg.Union());
+        builder.Finish(message); // Finished building message content to get serialised content.
+
+        // Now that we have built the content message,
+        // we need to place it inside a container message.
+        create_containermsg_from_content(container_builder, builder, {}, false);
+    }
+
+    /**
+     * Creates a unl sync response struct from the given unl response message.
+     * @param unl_response_message Flatbuffer unl response message received from the peer.
+     * @return A unl sync response struct representing the message.
+     */
+    const p2p::unl_sync_response create_unl_sync_response_from_msg(const Unl_Response_Message &unl_response_message)
+    {
+        p2p::unl_sync_response unl_sync_response;
+
+        unl_sync_response.requester_unl = flatbuff_bytes_to_sv(unl_response_message.requester_unl());
+        unl_sync_response.unl_list = flatbuf_bytearrayvector_to_stringlist(unl_response_message.unl_list());
+
+        return unl_sync_response;
+    }
+
     /**
  * 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.

src/msg/fbuf/p2pmsg_helpers.hpp

@@ -38,6 +38,10 @@ namespace msg::fbuf::p2pmsg
 
     const p2p::state_request create_state_request_from_msg(const State_Request_Message &msg);
     
+    const p2p::unl_sync_request create_unl_sync_request_from_msg(const Unl_Request_Message &unl_req_message);
+
+    const p2p::unl_sync_response create_unl_sync_response_from_msg(const Unl_Response_Message &unl_response_message);
+
     const std::vector<conf::peer_properties> create_peer_list_response_from_msg(const Peer_List_Response_Message &msg);
 
     //---Message creation helpers---//
@@ -57,6 +61,10 @@ namespace msg::fbuf::p2pmsg
 
     void create_msg_from_state_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::state_request &hr, std::string_view lcl);
 
+    void create_msg_from_unl_sync_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::unl_sync_request &unl_sync_message);
+
+    void create_msg_from_unl_sync_response(flatbuffers::FlatBufferBuilder &container_builder, const p2p::unl_sync_response &unl_response);
+
     void create_msg_from_fsentry_response(
         flatbuffers::FlatBufferBuilder &container_builder, const std::string_view path,
         std::vector<hpfs::child_hash_node> &hash_nodes, hpfs::h32 expected_hash, std::string_view lcl);