diff --git a/CMakeLists.txt b/CMakeLists.txt
index af9d25f6..4fffd9cc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,10 +11,11 @@ add_executable(hpcore
     src/crypto.cpp
     src/conf.cpp
     src/hplog.cpp
+    src/fbschema/common_helpers.cpp
+    src/fbschema/p2pmsg_helpers.cpp
     src/sock/socket_client.cpp
     src/sock/socket_server.cpp
     src/sock/socket_session.cpp
-    src/p2p/peer_message_handler.cpp
     src/p2p/peer_session_handler.cpp
     src/p2p/p2p.cpp
     src/usr/user_session_handler.cpp
diff --git a/src/cons/cons.cpp b/src/cons/cons.cpp
index e8ecfb8d..57014c64 100644
--- a/src/cons/cons.cpp
+++ b/src/cons/cons.cpp
@@ -4,13 +4,15 @@
 #include "../conf.hpp"
 #include "../usr/usr.hpp"
 #include "../p2p/p2p.hpp"
-#include "../p2p/peer_message_handler.hpp"
+#include "../fbschema/p2pmsg_helpers.hpp"
 #include "../p2p/peer_session_handler.hpp"
 #include "../hplog.hpp"
 #include "../crypto.hpp"
 #include "../proc.hpp"
 #include "cons.hpp"
 
+namespace p2pmsg = fbschema::p2pmsg;
+
 namespace cons
 {
 
@@ -313,12 +315,12 @@ p2p::proposal create_stage123_proposal(vote_counter &votes)
 
 /**
  * Broadcasts the given proposal to all connected peers.
- * @return 0 on success. -1 if not peers to broadcast.
+ * @return 0 on success. -1 if no peers to broadcast.
  */
 int broadcast_proposal(const p2p::proposal &p)
 {
     p2p::peer_outbound_message msg(std::make_shared<flatbuffers::FlatBufferBuilder>(1024));
-    p2p::create_msg_from_proposal(msg.builder(), p);
+    p2pmsg::create_msg_from_proposal(msg.builder(), p);
 
     {
         //Broadcast while locking the peer_connections.
diff --git a/src/fbschema/common_helpers.cpp b/src/fbschema/common_helpers.cpp
new file mode 100644
index 00000000..88813f83
--- /dev/null
+++ b/src/fbschema/common_helpers.cpp
@@ -0,0 +1,93 @@
+#include "common_helpers.hpp"
+
+namespace fbschema
+{
+
+//---Conversion helpers from flatbuffers data types to std data types---//
+
+/**
+ * Returns string_view from flat buffer data pointer and length.
+ */
+std::string_view flatbuff_bytes_to_sv(const uint8_t *data, flatbuffers::uoffset_t length)
+{
+    const char *signature_content_str = reinterpret_cast<const char *>(data);
+    return std::string_view(signature_content_str, length);
+}
+
+/**
+ * Returns return string_view from Flat Buffer vector of bytes.
+ */
+std::string_view flatbuff_bytes_to_sv(const flatbuffers::Vector<uint8_t> *buffer)
+{
+    return flatbuff_bytes_to_sv(buffer->Data(), buffer->size());
+}
+
+/**
+ * Returns set from Flatbuffer vector of ByteArrays.
+ */
+const std::unordered_set<std::string> flatbuf_bytearrayvector_to_stringlist(const flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *fbvec)
+{
+    std::unordered_set<std::string> set;
+    set.reserve(fbvec->size());
+    for (auto el : *fbvec)
+        set.emplace(std::string(flatbuff_bytes_to_sv(el->array())));
+    return set;
+}
+
+/**
+ * Returns a map from Flatbuffer vector of key value pairs.
+ */
+const std::unordered_map<std::string, const std::string>
+flatbuf_pairvector_to_stringmap(const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *fbvec)
+{
+    std::unordered_map<std::string, const std::string> map;
+    map.reserve(fbvec->size());
+    for (auto el : *fbvec)
+        map.emplace(flatbuff_bytes_to_sv(el->key()), flatbuff_bytes_to_sv(el->value()));
+    return map;
+}
+
+//---Conversion helpers from std data types to flatbuffers data types---//
+//---These are used in constructing Flatbuffer messages using builders---//
+
+/**
+ * Returns Flatbuffer bytes vector from string_view.
+ */
+const flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+sv_to_flatbuff_bytes(flatbuffers::FlatBufferBuilder &builder, std::string_view sv)
+{
+    return builder.CreateVector(reinterpret_cast<const uint8_t *>(sv.data()), sv.size());
+}
+
+/**
+ * Returns Flatbuffer vector of ByteArrays from given set of strings.
+ */
+const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ByteArray>>>
+stringlist_to_flatbuf_bytearrayvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_set<std::string> &set)
+{
+    std::vector<flatbuffers::Offset<ByteArray>> fbvec;
+    fbvec.reserve(set.size());
+    for (std::string_view str : set)
+        fbvec.push_back(CreateByteArray(builder, sv_to_flatbuff_bytes(builder, str)));
+    return builder.CreateVector(fbvec);
+}
+
+/**
+ * Returns Flatbuffer vector of key value pairs from given map.
+ */
+const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>>
+stringmap_to_flatbuf_bytepairvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map<std::string, const std::string> &map)
+{
+    std::vector<flatbuffers::Offset<BytesKeyValuePair>> fbvec;
+    fbvec.reserve(map.size());
+    for (auto const &[key, value] : map)
+    {
+        fbvec.push_back(CreateBytesKeyValuePair(
+            builder,
+            sv_to_flatbuff_bytes(builder, key),
+            sv_to_flatbuff_bytes(builder, value)));
+    }
+    return builder.CreateVector(fbvec);
+}
+
+} // namespace fbschema
\ No newline at end of file
diff --git a/src/fbschema/common_helpers.hpp b/src/fbschema/common_helpers.hpp
new file mode 100644
index 00000000..03b2158d
--- /dev/null
+++ b/src/fbschema/common_helpers.hpp
@@ -0,0 +1,40 @@
+#ifndef _HP_FBSCHEMA_COMMON_HELPERS_H_
+#define _HP_FBSCHEMA_COMMON_HELPERS_H_
+
+#include <string>
+#include <unordered_set>
+#include <flatbuffers/flatbuffers.h>
+#include "common_schema_generated.h"
+
+namespace fbschema
+{
+/**
+ * This section contains common Flatbuffer message reading/writing helpers.
+ */
+
+//---Conversion helpers from flatbuffers data types to std data types---//
+
+std::string_view flatbuff_bytes_to_sv(const uint8_t *data, flatbuffers::uoffset_t length);
+
+std::string_view flatbuff_bytes_to_sv(const flatbuffers::Vector<uint8_t> *buffer);
+
+const std::unordered_set<std::string>
+flatbuf_bytearrayvector_to_stringlist(const flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *fbvec);
+
+const std::unordered_map<std::string, const std::string>
+flatbuf_pairvector_to_stringmap(const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *fbvec);
+
+//---Conversion helpers from std data types to flatbuffers data types---//
+
+const flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
+sv_to_flatbuff_bytes(flatbuffers::FlatBufferBuilder &builder, std::string_view sv);
+
+const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ByteArray>>>
+stringlist_to_flatbuf_bytearrayvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_set<std::string> &set);
+
+const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>>
+stringmap_to_flatbuf_bytepairvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map<std::string, const std::string> &map);
+
+} // namespace fbschema
+
+#endif
\ No newline at end of file
diff --git a/src/fbschema/common_schema.fbs b/src/fbschema/common_schema.fbs
new file mode 100644
index 00000000..85fb7a4c
--- /dev/null
+++ b/src/fbschema/common_schema.fbs
@@ -0,0 +1,11 @@
+//IDL file for common types.
+namespace fbschema;
+
+table BytesKeyValuePair { //A key, value pair of byte[].
+    key:[ubyte];
+    value:[ubyte];
+}
+
+table ByteArray { //To represent list of byte arrays
+    array:[ubyte];
+}
diff --git a/src/fbschema/common_schema_generated.h b/src/fbschema/common_schema_generated.h
new file mode 100644
index 00000000..1e94fdb6
--- /dev/null
+++ b/src/fbschema/common_schema_generated.h
@@ -0,0 +1,140 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_COMMONSCHEMA_FBSCHEMA_H_
+#define FLATBUFFERS_GENERATED_COMMONSCHEMA_FBSCHEMA_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace fbschema {
+
+struct BytesKeyValuePair;
+
+struct ByteArray;
+
+struct BytesKeyValuePair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_KEY = 4,
+    VT_VALUE = 6
+  };
+  const flatbuffers::Vector<uint8_t> *key() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_KEY);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_key() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_KEY);
+  }
+  const flatbuffers::Vector<uint8_t> *value() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUE);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_value() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_VALUE);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_KEY) &&
+           verifier.VerifyVector(key()) &&
+           VerifyOffset(verifier, VT_VALUE) &&
+           verifier.VerifyVector(value()) &&
+           verifier.EndTable();
+  }
+};
+
+struct BytesKeyValuePairBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_key(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> key) {
+    fbb_.AddOffset(BytesKeyValuePair::VT_KEY, key);
+  }
+  void add_value(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> value) {
+    fbb_.AddOffset(BytesKeyValuePair::VT_VALUE, value);
+  }
+  explicit BytesKeyValuePairBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  BytesKeyValuePairBuilder &operator=(const BytesKeyValuePairBuilder &);
+  flatbuffers::Offset<BytesKeyValuePair> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<BytesKeyValuePair>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<BytesKeyValuePair> CreateBytesKeyValuePair(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> key = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> value = 0) {
+  BytesKeyValuePairBuilder builder_(_fbb);
+  builder_.add_value(value);
+  builder_.add_key(key);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<BytesKeyValuePair> CreateBytesKeyValuePairDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<uint8_t> *key = nullptr,
+    const std::vector<uint8_t> *value = nullptr) {
+  auto key__ = key ? _fbb.CreateVector<uint8_t>(*key) : 0;
+  auto value__ = value ? _fbb.CreateVector<uint8_t>(*value) : 0;
+  return fbschema::CreateBytesKeyValuePair(
+      _fbb,
+      key__,
+      value__);
+}
+
+struct ByteArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ARRAY = 4
+  };
+  const flatbuffers::Vector<uint8_t> *array() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_ARRAY);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_array() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_ARRAY);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_ARRAY) &&
+           verifier.VerifyVector(array()) &&
+           verifier.EndTable();
+  }
+};
+
+struct ByteArrayBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_array(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> array) {
+    fbb_.AddOffset(ByteArray::VT_ARRAY, array);
+  }
+  explicit ByteArrayBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ByteArrayBuilder &operator=(const ByteArrayBuilder &);
+  flatbuffers::Offset<ByteArray> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<ByteArray>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<ByteArray> CreateByteArray(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> array = 0) {
+  ByteArrayBuilder builder_(_fbb);
+  builder_.add_array(array);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<ByteArray> CreateByteArrayDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<uint8_t> *array = nullptr) {
+  auto array__ = array ? _fbb.CreateVector<uint8_t>(*array) : 0;
+  return fbschema::CreateByteArray(
+      _fbb,
+      array__);
+}
+
+}  // namespace fbschema
+
+#endif  // FLATBUFFERS_GENERATED_COMMONSCHEMA_FBSCHEMA_H_
diff --git a/src/p2p/message_container.fbs b/src/fbschema/p2pmsg_container.fbs
similarity index 87%
rename from src/p2p/message_container.fbs
rename to src/fbschema/p2pmsg_container.fbs
index 0b14fab5..a76958b3 100644
--- a/src/p2p/message_container.fbs
+++ b/src/fbschema/p2pmsg_container.fbs
@@ -2,8 +2,8 @@
 /*Message content need to be serialised and parsed into container, we need two root types in flatbuffs to generat
  needed api methods. Since Flatbuff only support one rrot at each IDL files, we had to seperate message schema to 2 files.
 */
-include "message_content.fbs";
-namespace p2p;
+include "p2pmsg_content.fbs";
+namespace fbschema.p2pmsg;
 
 table Container { //root type for message
     version:uint16;
diff --git a/src/p2p/message_container_generated.h b/src/fbschema/p2pmsg_container_generated.h
similarity index 83%
rename from src/p2p/message_container_generated.h
rename to src/fbschema/p2pmsg_container_generated.h
index 459be17d..d5cf5a72 100644
--- a/src/p2p/message_container_generated.h
+++ b/src/fbschema/p2pmsg_container_generated.h
@@ -1,14 +1,16 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 
 
-#ifndef FLATBUFFERS_GENERATED_MESSAGECONTAINER_P2P_H_
-#define FLATBUFFERS_GENERATED_MESSAGECONTAINER_P2P_H_
+#ifndef FLATBUFFERS_GENERATED_P2PMSGCONTAINER_FBSCHEMA_P2PMSG_H_
+#define FLATBUFFERS_GENERATED_P2PMSGCONTAINER_FBSCHEMA_P2PMSG_H_
 
 #include "flatbuffers/flatbuffers.h"
 
-#include "message_content_generated.h"
+#include "common_schema_generated.h"
+#include "p2pmsg_content_generated.h"
 
-namespace p2p {
+namespace fbschema {
+namespace p2pmsg {
 
 struct Container;
 
@@ -120,7 +122,7 @@ inline flatbuffers::Offset<Container> CreateContainerDirect(
   auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
   auto signature__ = signature ? _fbb.CreateVector<uint8_t>(*signature) : 0;
   auto content__ = content ? _fbb.CreateVector<uint8_t>(*content) : 0;
-  return p2p::CreateContainer(
+  return fbschema::p2pmsg::CreateContainer(
       _fbb,
       version,
       timestamp,
@@ -129,12 +131,12 @@ inline flatbuffers::Offset<Container> CreateContainerDirect(
       content__);
 }
 
-inline const p2p::Container *GetContainer(const void *buf) {
-  return flatbuffers::GetRoot<p2p::Container>(buf);
+inline const fbschema::p2pmsg::Container *GetContainer(const void *buf) {
+  return flatbuffers::GetRoot<fbschema::p2pmsg::Container>(buf);
 }
 
-inline const p2p::Container *GetSizePrefixedContainer(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<p2p::Container>(buf);
+inline const fbschema::p2pmsg::Container *GetSizePrefixedContainer(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<fbschema::p2pmsg::Container>(buf);
 }
 
 inline Container *GetMutableContainer(void *buf) {
@@ -143,26 +145,27 @@ inline Container *GetMutableContainer(void *buf) {
 
 inline bool VerifyContainerBuffer(
     flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<p2p::Container>(nullptr);
+  return verifier.VerifyBuffer<fbschema::p2pmsg::Container>(nullptr);
 }
 
 inline bool VerifySizePrefixedContainerBuffer(
     flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<p2p::Container>(nullptr);
+  return verifier.VerifySizePrefixedBuffer<fbschema::p2pmsg::Container>(nullptr);
 }
 
 inline void FinishContainerBuffer(
     flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<p2p::Container> root) {
+    flatbuffers::Offset<fbschema::p2pmsg::Container> root) {
   fbb.Finish(root);
 }
 
 inline void FinishSizePrefixedContainerBuffer(
     flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<p2p::Container> root) {
+    flatbuffers::Offset<fbschema::p2pmsg::Container> root) {
   fbb.FinishSizePrefixed(root);
 }
 
-}  // namespace p2p
+}  // namespace p2pmsg
+}  // namespace fbschema
 
-#endif  // FLATBUFFERS_GENERATED_MESSAGECONTAINER_P2P_H_
+#endif  // FLATBUFFERS_GENERATED_P2PMSGCONTAINER_FBSCHEMA_P2PMSG_H_
diff --git a/src/p2p/message_content.fbs b/src/fbschema/p2pmsg_content.fbs
similarity index 86%
rename from src/p2p/message_content.fbs
rename to src/fbschema/p2pmsg_content.fbs
index 063d2946..d89848e4 100644
--- a/src/p2p/message_content.fbs
+++ b/src/fbschema/p2pmsg_content.fbs
@@ -1,10 +1,6 @@
 //IDL file for p2p message content schema.
-namespace p2p;
-
-table BytesKeyValuePair { //A key, value pair of byte[].
-    key:[ubyte];
-    value:[ubyte];
-}
+include "common_schema.fbs";
+namespace fbschema.p2pmsg;
 
 table RawInputList { //Pubkey bytes with an array of key value pairs.
     pubkey:[ubyte];
@@ -16,10 +12,6 @@ table RawOutput { //Pubkey bytes with a output key value pair.
     output:BytesKeyValuePair;
 }
 
-table ByteArray { //To represent list of byte arrays
-    array:[ubyte];
-}
-
 union Message { Proposal_Message, Npl_Message } //message content type
 
 table Content {
diff --git a/src/p2p/message_content_generated.h b/src/fbschema/p2pmsg_content_generated.h
similarity index 73%
rename from src/p2p/message_content_generated.h
rename to src/fbschema/p2pmsg_content_generated.h
index d032d9b1..a72f97fa 100644
--- a/src/p2p/message_content_generated.h
+++ b/src/fbschema/p2pmsg_content_generated.h
@@ -1,21 +1,20 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 
 
-#ifndef FLATBUFFERS_GENERATED_MESSAGECONTENT_P2P_H_
-#define FLATBUFFERS_GENERATED_MESSAGECONTENT_P2P_H_
+#ifndef FLATBUFFERS_GENERATED_P2PMSGCONTENT_FBSCHEMA_P2PMSG_H_
+#define FLATBUFFERS_GENERATED_P2PMSGCONTENT_FBSCHEMA_P2PMSG_H_
 
 #include "flatbuffers/flatbuffers.h"
 
-namespace p2p {
+#include "common_schema_generated.h"
 
-struct BytesKeyValuePair;
+namespace fbschema {
+namespace p2pmsg {
 
 struct RawInputList;
 
 struct RawOutput;
 
-struct ByteArray;
-
 struct Content;
 
 struct Proposal_Message;
@@ -74,76 +73,6 @@ template<> struct MessageTraits<Npl_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);
 
-struct BytesKeyValuePair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_KEY = 4,
-    VT_VALUE = 6
-  };
-  const flatbuffers::Vector<uint8_t> *key() const {
-    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_KEY);
-  }
-  flatbuffers::Vector<uint8_t> *mutable_key() {
-    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_KEY);
-  }
-  const flatbuffers::Vector<uint8_t> *value() const {
-    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUE);
-  }
-  flatbuffers::Vector<uint8_t> *mutable_value() {
-    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_VALUE);
-  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_KEY) &&
-           verifier.VerifyVector(key()) &&
-           VerifyOffset(verifier, VT_VALUE) &&
-           verifier.VerifyVector(value()) &&
-           verifier.EndTable();
-  }
-};
-
-struct BytesKeyValuePairBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  void add_key(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> key) {
-    fbb_.AddOffset(BytesKeyValuePair::VT_KEY, key);
-  }
-  void add_value(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> value) {
-    fbb_.AddOffset(BytesKeyValuePair::VT_VALUE, value);
-  }
-  explicit BytesKeyValuePairBuilder(flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  BytesKeyValuePairBuilder &operator=(const BytesKeyValuePairBuilder &);
-  flatbuffers::Offset<BytesKeyValuePair> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<BytesKeyValuePair>(end);
-    return o;
-  }
-};
-
-inline flatbuffers::Offset<BytesKeyValuePair> CreateBytesKeyValuePair(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> key = 0,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> value = 0) {
-  BytesKeyValuePairBuilder builder_(_fbb);
-  builder_.add_value(value);
-  builder_.add_key(key);
-  return builder_.Finish();
-}
-
-inline flatbuffers::Offset<BytesKeyValuePair> CreateBytesKeyValuePairDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    const std::vector<uint8_t> *key = nullptr,
-    const std::vector<uint8_t> *value = nullptr) {
-  auto key__ = key ? _fbb.CreateVector<uint8_t>(*key) : 0;
-  auto value__ = value ? _fbb.CreateVector<uint8_t>(*value) : 0;
-  return p2p::CreateBytesKeyValuePair(
-      _fbb,
-      key__,
-      value__);
-}
-
 struct RawInputList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_PUBKEY = 4,
@@ -155,11 +84,11 @@ struct RawInputList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   flatbuffers::Vector<uint8_t> *mutable_pubkey() {
     return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *inputs() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *>(VT_INPUTS);
+  const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *inputs() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_INPUTS);
   }
-  flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *mutable_inputs() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *>(VT_INPUTS);
+  flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *mutable_inputs() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_INPUTS);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
@@ -178,7 +107,7 @@ struct RawInputListBuilder {
   void add_pubkey(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey) {
     fbb_.AddOffset(RawInputList::VT_PUBKEY, pubkey);
   }
-  void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>> inputs) {
+  void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> inputs) {
     fbb_.AddOffset(RawInputList::VT_INPUTS, inputs);
   }
   explicit RawInputListBuilder(flatbuffers::FlatBufferBuilder &_fbb)
@@ -196,7 +125,7 @@ struct RawInputListBuilder {
 inline flatbuffers::Offset<RawInputList> CreateRawInputList(
     flatbuffers::FlatBufferBuilder &_fbb,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>> inputs = 0) {
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> inputs = 0) {
   RawInputListBuilder builder_(_fbb);
   builder_.add_inputs(inputs);
   builder_.add_pubkey(pubkey);
@@ -206,10 +135,10 @@ inline flatbuffers::Offset<RawInputList> CreateRawInputList(
 inline flatbuffers::Offset<RawInputList> CreateRawInputListDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
     const std::vector<uint8_t> *pubkey = nullptr,
-    const std::vector<flatbuffers::Offset<BytesKeyValuePair>> *inputs = nullptr) {
+    const std::vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *inputs = nullptr) {
   auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
-  auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<BytesKeyValuePair>>(*inputs) : 0;
-  return p2p::CreateRawInputList(
+  auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>(*inputs) : 0;
+  return fbschema::p2pmsg::CreateRawInputList(
       _fbb,
       pubkey__,
       inputs__);
@@ -226,11 +155,11 @@ struct RawOutput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   flatbuffers::Vector<uint8_t> *mutable_pubkey() {
     return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
   }
-  const BytesKeyValuePair *output() const {
-    return GetPointer<const BytesKeyValuePair *>(VT_OUTPUT);
+  const fbschema::BytesKeyValuePair *output() const {
+    return GetPointer<const fbschema::BytesKeyValuePair *>(VT_OUTPUT);
   }
-  BytesKeyValuePair *mutable_output() {
-    return GetPointer<BytesKeyValuePair *>(VT_OUTPUT);
+  fbschema::BytesKeyValuePair *mutable_output() {
+    return GetPointer<fbschema::BytesKeyValuePair *>(VT_OUTPUT);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
@@ -248,7 +177,7 @@ struct RawOutputBuilder {
   void add_pubkey(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey) {
     fbb_.AddOffset(RawOutput::VT_PUBKEY, pubkey);
   }
-  void add_output(flatbuffers::Offset<BytesKeyValuePair> output) {
+  void add_output(flatbuffers::Offset<fbschema::BytesKeyValuePair> output) {
     fbb_.AddOffset(RawOutput::VT_OUTPUT, output);
   }
   explicit RawOutputBuilder(flatbuffers::FlatBufferBuilder &_fbb)
@@ -266,7 +195,7 @@ struct RawOutputBuilder {
 inline flatbuffers::Offset<RawOutput> CreateRawOutput(
     flatbuffers::FlatBufferBuilder &_fbb,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey = 0,
-    flatbuffers::Offset<BytesKeyValuePair> output = 0) {
+    flatbuffers::Offset<fbschema::BytesKeyValuePair> output = 0) {
   RawOutputBuilder builder_(_fbb);
   builder_.add_output(output);
   builder_.add_pubkey(pubkey);
@@ -276,67 +205,14 @@ inline flatbuffers::Offset<RawOutput> CreateRawOutput(
 inline flatbuffers::Offset<RawOutput> CreateRawOutputDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
     const std::vector<uint8_t> *pubkey = nullptr,
-    flatbuffers::Offset<BytesKeyValuePair> output = 0) {
+    flatbuffers::Offset<fbschema::BytesKeyValuePair> output = 0) {
   auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
-  return p2p::CreateRawOutput(
+  return fbschema::p2pmsg::CreateRawOutput(
       _fbb,
       pubkey__,
       output);
 }
 
-struct ByteArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_ARRAY = 4
-  };
-  const flatbuffers::Vector<uint8_t> *array() const {
-    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_ARRAY);
-  }
-  flatbuffers::Vector<uint8_t> *mutable_array() {
-    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_ARRAY);
-  }
-  bool Verify(flatbuffers::Verifier &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_ARRAY) &&
-           verifier.VerifyVector(array()) &&
-           verifier.EndTable();
-  }
-};
-
-struct ByteArrayBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  void add_array(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> array) {
-    fbb_.AddOffset(ByteArray::VT_ARRAY, array);
-  }
-  explicit ByteArrayBuilder(flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ByteArrayBuilder &operator=(const ByteArrayBuilder &);
-  flatbuffers::Offset<ByteArray> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<ByteArray>(end);
-    return o;
-  }
-};
-
-inline flatbuffers::Offset<ByteArray> CreateByteArray(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> array = 0) {
-  ByteArrayBuilder builder_(_fbb);
-  builder_.add_array(array);
-  return builder_.Finish();
-}
-
-inline flatbuffers::Offset<ByteArray> CreateByteArrayDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    const std::vector<uint8_t> *array = nullptr) {
-  auto array__ = array ? _fbb.CreateVector<uint8_t>(*array) : 0;
-  return p2p::CreateByteArray(
-      _fbb,
-      array__);
-}
-
 struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_MESSAGE_TYPE = 4,
@@ -439,11 +315,11 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   flatbuffers::Vector<uint8_t> *mutable_lcl() {
     return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_LCL);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *users() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *>(VT_USERS);
+  const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *users() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_USERS);
   }
-  flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *mutable_users() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *>(VT_USERS);
+  flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *mutable_users() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_USERS);
   }
   const flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *raw_inputs() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *>(VT_RAW_INPUTS);
@@ -451,11 +327,11 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *mutable_raw_inputs() {
     return GetPointer<flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *>(VT_RAW_INPUTS);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *hash_inputs() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *>(VT_HASH_INPUTS);
+  const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *hash_inputs() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_HASH_INPUTS);
   }
-  flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *mutable_hash_inputs() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *>(VT_HASH_INPUTS);
+  flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *mutable_hash_inputs() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_HASH_INPUTS);
   }
   const flatbuffers::Vector<flatbuffers::Offset<RawOutput>> *raw_outputs() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RawOutput>> *>(VT_RAW_OUTPUTS);
@@ -463,11 +339,11 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   flatbuffers::Vector<flatbuffers::Offset<RawOutput>> *mutable_raw_outputs() {
     return GetPointer<flatbuffers::Vector<flatbuffers::Offset<RawOutput>> *>(VT_RAW_OUTPUTS);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *hash_outputs() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *>(VT_HASH_OUTPUTS);
+  const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *hash_outputs() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_HASH_OUTPUTS);
   }
-  flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *mutable_hash_outputs() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *>(VT_HASH_OUTPUTS);
+  flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *mutable_hash_outputs() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_HASH_OUTPUTS);
   }
   const State *state() const {
     return GetPointer<const State *>(VT_STATE);
@@ -514,19 +390,19 @@ struct Proposal_MessageBuilder {
   void add_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl) {
     fbb_.AddOffset(Proposal_Message::VT_LCL, lcl);
   }
-  void add_users(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ByteArray>>> users) {
+  void add_users(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> users) {
     fbb_.AddOffset(Proposal_Message::VT_USERS, users);
   }
   void add_raw_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawInputList>>> raw_inputs) {
     fbb_.AddOffset(Proposal_Message::VT_RAW_INPUTS, raw_inputs);
   }
-  void add_hash_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ByteArray>>> hash_inputs) {
+  void add_hash_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> hash_inputs) {
     fbb_.AddOffset(Proposal_Message::VT_HASH_INPUTS, hash_inputs);
   }
   void add_raw_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawOutput>>> raw_outputs) {
     fbb_.AddOffset(Proposal_Message::VT_RAW_OUTPUTS, raw_outputs);
   }
-  void add_hash_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ByteArray>>> hash_outputs) {
+  void add_hash_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> hash_outputs) {
     fbb_.AddOffset(Proposal_Message::VT_HASH_OUTPUTS, hash_outputs);
   }
   void add_state(flatbuffers::Offset<State> state) {
@@ -549,11 +425,11 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_Message(
     int8_t stage = 0,
     uint64_t time = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ByteArray>>> users = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> users = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawInputList>>> raw_inputs = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ByteArray>>> hash_inputs = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> hash_inputs = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawOutput>>> raw_outputs = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ByteArray>>> hash_outputs = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> hash_outputs = 0,
     flatbuffers::Offset<State> state = 0) {
   Proposal_MessageBuilder builder_(_fbb);
   builder_.add_time(time);
@@ -573,19 +449,19 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_MessageDirect(
     int8_t stage = 0,
     uint64_t time = 0,
     const std::vector<uint8_t> *lcl = nullptr,
-    const std::vector<flatbuffers::Offset<ByteArray>> *users = nullptr,
+    const std::vector<flatbuffers::Offset<fbschema::ByteArray>> *users = nullptr,
     const std::vector<flatbuffers::Offset<RawInputList>> *raw_inputs = nullptr,
-    const std::vector<flatbuffers::Offset<ByteArray>> *hash_inputs = nullptr,
+    const std::vector<flatbuffers::Offset<fbschema::ByteArray>> *hash_inputs = nullptr,
     const std::vector<flatbuffers::Offset<RawOutput>> *raw_outputs = nullptr,
-    const std::vector<flatbuffers::Offset<ByteArray>> *hash_outputs = nullptr,
+    const std::vector<flatbuffers::Offset<fbschema::ByteArray>> *hash_outputs = nullptr,
     flatbuffers::Offset<State> state = 0) {
   auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
-  auto users__ = users ? _fbb.CreateVector<flatbuffers::Offset<ByteArray>>(*users) : 0;
+  auto users__ = users ? _fbb.CreateVector<flatbuffers::Offset<fbschema::ByteArray>>(*users) : 0;
   auto raw_inputs__ = raw_inputs ? _fbb.CreateVector<flatbuffers::Offset<RawInputList>>(*raw_inputs) : 0;
-  auto hash_inputs__ = hash_inputs ? _fbb.CreateVector<flatbuffers::Offset<ByteArray>>(*hash_inputs) : 0;
+  auto hash_inputs__ = hash_inputs ? _fbb.CreateVector<flatbuffers::Offset<fbschema::ByteArray>>(*hash_inputs) : 0;
   auto raw_outputs__ = raw_outputs ? _fbb.CreateVector<flatbuffers::Offset<RawOutput>>(*raw_outputs) : 0;
-  auto hash_outputs__ = hash_outputs ? _fbb.CreateVector<flatbuffers::Offset<ByteArray>>(*hash_outputs) : 0;
-  return p2p::CreateProposal_Message(
+  auto hash_outputs__ = hash_outputs ? _fbb.CreateVector<flatbuffers::Offset<fbschema::ByteArray>>(*hash_outputs) : 0;
+  return fbschema::p2pmsg::CreateProposal_Message(
       _fbb,
       stage,
       time,
@@ -692,7 +568,7 @@ inline flatbuffers::Offset<Npl_Message> CreateNpl_MessageDirect(
   auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
   auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
   auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
-  return p2p::CreateNpl_Message(
+  return fbschema::p2pmsg::CreateNpl_Message(
       _fbb,
       pubkey__,
       timestamp,
@@ -706,23 +582,23 @@ struct StateDifference FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_UPDATED = 6,
     VT_DELETED = 8
   };
-  const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *created() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *>(VT_CREATED);
+  const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *created() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_CREATED);
   }
-  flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *mutable_created() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *>(VT_CREATED);
+  flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *mutable_created() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_CREATED);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *updated() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *>(VT_UPDATED);
+  const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *updated() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_UPDATED);
   }
-  flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *mutable_updated() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *>(VT_UPDATED);
+  flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *mutable_updated() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_UPDATED);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *deleted() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *>(VT_DELETED);
+  const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *deleted() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_DELETED);
   }
-  flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *mutable_deleted() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *>(VT_DELETED);
+  flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *mutable_deleted() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_DELETED);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
@@ -742,13 +618,13 @@ struct StateDifference FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 struct StateDifferenceBuilder {
   flatbuffers::FlatBufferBuilder &fbb_;
   flatbuffers::uoffset_t start_;
-  void add_created(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>> created) {
+  void add_created(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> created) {
     fbb_.AddOffset(StateDifference::VT_CREATED, created);
   }
-  void add_updated(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>> updated) {
+  void add_updated(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> updated) {
     fbb_.AddOffset(StateDifference::VT_UPDATED, updated);
   }
-  void add_deleted(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>> deleted) {
+  void add_deleted(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> deleted) {
     fbb_.AddOffset(StateDifference::VT_DELETED, deleted);
   }
   explicit StateDifferenceBuilder(flatbuffers::FlatBufferBuilder &_fbb)
@@ -765,9 +641,9 @@ struct StateDifferenceBuilder {
 
 inline flatbuffers::Offset<StateDifference> CreateStateDifference(
     flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>> created = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>> updated = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>> deleted = 0) {
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> created = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> updated = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> deleted = 0) {
   StateDifferenceBuilder builder_(_fbb);
   builder_.add_deleted(deleted);
   builder_.add_updated(updated);
@@ -777,13 +653,13 @@ inline flatbuffers::Offset<StateDifference> CreateStateDifference(
 
 inline flatbuffers::Offset<StateDifference> CreateStateDifferenceDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
-    const std::vector<flatbuffers::Offset<BytesKeyValuePair>> *created = nullptr,
-    const std::vector<flatbuffers::Offset<BytesKeyValuePair>> *updated = nullptr,
-    const std::vector<flatbuffers::Offset<BytesKeyValuePair>> *deleted = nullptr) {
-  auto created__ = created ? _fbb.CreateVector<flatbuffers::Offset<BytesKeyValuePair>>(*created) : 0;
-  auto updated__ = updated ? _fbb.CreateVector<flatbuffers::Offset<BytesKeyValuePair>>(*updated) : 0;
-  auto deleted__ = deleted ? _fbb.CreateVector<flatbuffers::Offset<BytesKeyValuePair>>(*deleted) : 0;
-  return p2p::CreateStateDifference(
+    const std::vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *created = nullptr,
+    const std::vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *updated = nullptr,
+    const std::vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *deleted = nullptr) {
+  auto created__ = created ? _fbb.CreateVector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>(*created) : 0;
+  auto updated__ = updated ? _fbb.CreateVector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>(*updated) : 0;
+  auto deleted__ = deleted ? _fbb.CreateVector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>(*deleted) : 0;
+  return fbschema::p2pmsg::CreateStateDifference(
       _fbb,
       created__,
       updated__,
@@ -815,11 +691,11 @@ struct State FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   StateDifference *mutable_difference() {
     return GetPointer<StateDifference *>(VT_DIFFERENCE);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *patch() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *>(VT_PATCH);
+  const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *patch() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_PATCH);
   }
-  flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *mutable_patch() {
-    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *>(VT_PATCH);
+  flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *mutable_patch() {
+    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_PATCH);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
@@ -848,7 +724,7 @@ struct StateBuilder {
   void add_difference(flatbuffers::Offset<StateDifference> difference) {
     fbb_.AddOffset(State::VT_DIFFERENCE, difference);
   }
-  void add_patch(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>> patch) {
+  void add_patch(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> patch) {
     fbb_.AddOffset(State::VT_PATCH, patch);
   }
   explicit StateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
@@ -868,7 +744,7 @@ inline flatbuffers::Offset<State> CreateState(
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> previous = 0,
     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> current = 0,
     flatbuffers::Offset<StateDifference> difference = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>> patch = 0) {
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> patch = 0) {
   StateBuilder builder_(_fbb);
   builder_.add_patch(patch);
   builder_.add_difference(difference);
@@ -882,11 +758,11 @@ inline flatbuffers::Offset<State> CreateStateDirect(
     const std::vector<uint8_t> *previous = nullptr,
     const std::vector<uint8_t> *current = nullptr,
     flatbuffers::Offset<StateDifference> difference = 0,
-    const std::vector<flatbuffers::Offset<BytesKeyValuePair>> *patch = nullptr) {
+    const std::vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *patch = nullptr) {
   auto previous__ = previous ? _fbb.CreateVector<uint8_t>(*previous) : 0;
   auto current__ = current ? _fbb.CreateVector<uint8_t>(*current) : 0;
-  auto patch__ = patch ? _fbb.CreateVector<flatbuffers::Offset<BytesKeyValuePair>>(*patch) : 0;
-  return p2p::CreateState(
+  auto patch__ = patch ? _fbb.CreateVector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>(*patch) : 0;
+  return fbschema::p2pmsg::CreateState(
       _fbb,
       previous__,
       current__,
@@ -923,12 +799,12 @@ inline bool VerifyMessageVector(flatbuffers::Verifier &verifier, const flatbuffe
   return true;
 }
 
-inline const p2p::Content *GetContent(const void *buf) {
-  return flatbuffers::GetRoot<p2p::Content>(buf);
+inline const fbschema::p2pmsg::Content *GetContent(const void *buf) {
+  return flatbuffers::GetRoot<fbschema::p2pmsg::Content>(buf);
 }
 
-inline const p2p::Content *GetSizePrefixedContent(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<p2p::Content>(buf);
+inline const fbschema::p2pmsg::Content *GetSizePrefixedContent(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<fbschema::p2pmsg::Content>(buf);
 }
 
 inline Content *GetMutableContent(void *buf) {
@@ -937,26 +813,27 @@ inline Content *GetMutableContent(void *buf) {
 
 inline bool VerifyContentBuffer(
     flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<p2p::Content>(nullptr);
+  return verifier.VerifyBuffer<fbschema::p2pmsg::Content>(nullptr);
 }
 
 inline bool VerifySizePrefixedContentBuffer(
     flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<p2p::Content>(nullptr);
+  return verifier.VerifySizePrefixedBuffer<fbschema::p2pmsg::Content>(nullptr);
 }
 
 inline void FinishContentBuffer(
     flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<p2p::Content> root) {
+    flatbuffers::Offset<fbschema::p2pmsg::Content> root) {
   fbb.Finish(root);
 }
 
 inline void FinishSizePrefixedContentBuffer(
     flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<p2p::Content> root) {
+    flatbuffers::Offset<fbschema::p2pmsg::Content> root) {
   fbb.FinishSizePrefixed(root);
 }
 
-}  // namespace p2p
+}  // namespace p2pmsg
+}  // namespace fbschema
 
-#endif  // FLATBUFFERS_GENERATED_MESSAGECONTENT_P2P_H_
+#endif  // FLATBUFFERS_GENERATED_P2PMSGCONTENT_FBSCHEMA_P2PMSG_H_
diff --git a/src/p2p/peer_message_handler.cpp b/src/fbschema/p2pmsg_helpers.cpp
similarity index 81%
rename from src/p2p/peer_message_handler.cpp
rename to src/fbschema/p2pmsg_helpers.cpp
index 5f92091e..d8550145 100644
--- a/src/p2p/peer_message_handler.cpp
+++ b/src/fbschema/p2pmsg_helpers.cpp
@@ -4,11 +4,13 @@
 #include "../crypto.hpp"
 #include "../util.hpp"
 #include "../hplog.hpp"
-#include "peer_message_handler.hpp"
-#include "message_content_generated.h"
-#include "message_container_generated.h"
+#include "../p2p/p2p.hpp"
+#include "p2pmsg_container_generated.h"
+#include "p2pmsg_content_generated.h"
+#include "common_helpers.hpp"
+#include "p2pmsg_helpers.hpp"
 
-namespace p2p
+namespace fbschema::p2pmsg
 {
 
 /**
@@ -160,9 +162,9 @@ int validate_and_extract_content(const Content **content_ref, const uint8_t *con
  * @param The Flatbuffer poporal received from the peer.
  * @return A proposal struct representing the message.
  */
-const proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector<uint8_t> *pubkey)
+const p2p::proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector<uint8_t> *pubkey)
 {
-    proposal p;
+    p2p::proposal p;
 
     p.pubkey = flatbuff_bytes_to_sv(pubkey);
     p.time = msg.time();
@@ -196,7 +198,7 @@ const proposal create_proposal_from_msg(const Proposal_Message &msg, const flatb
  * @param container_builder Flatbuffer builder for the container message.
  * @param p The proposal struct to be placed in the container message.
  */
-void create_msg_from_proposal(flatbuffers::FlatBufferBuilder &container_builder, const proposal &p)
+void create_msg_from_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::proposal &p)
 {
     // todo:get a average propsal message size and allocate content builder based on that.
     flatbuffers::FlatBufferBuilder builder(1024);
@@ -264,48 +266,6 @@ void create_containermsg_from_content(
 
 //---Conversion helpers from flatbuffers data types to std data types---//
 
-/**
- * Returns string_view from flat buffer data pointer and length.
- */
-std::string_view flatbuff_bytes_to_sv(const uint8_t *data, flatbuffers::uoffset_t length)
-{
-    const char *signature_content_str = reinterpret_cast<const char *>(data);
-    return std::string_view(signature_content_str, length);
-}
-
-/**
- * Returns return string_view from Flat Buffer vector of bytes.
- */
-std::string_view flatbuff_bytes_to_sv(const flatbuffers::Vector<uint8_t> *buffer)
-{
-    return flatbuff_bytes_to_sv(buffer->Data(), buffer->size());
-}
-
-/**
- * Returns set from Flatbuffer vector of ByteArrays.
- */
-const std::unordered_set<std::string> flatbuf_bytearrayvector_to_stringlist(const flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *fbvec)
-{
-    std::unordered_set<std::string> set;
-    set.reserve(fbvec->size());
-    for (auto el : *fbvec)
-        set.emplace(std::string(flatbuff_bytes_to_sv(el->array())));
-    return set;
-}
-
-/**
- * Returns a map from Flatbuffer vector of key value pairs.
- */
-const std::unordered_map<std::string, const std::string>
-flatbuf_pairvector_to_stringmap(const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *fbvec)
-{
-    std::unordered_map<std::string, const std::string> map;
-    map.reserve(fbvec->size());
-    for (auto el : *fbvec)
-        map.emplace(flatbuff_bytes_to_sv(el->key()), flatbuff_bytes_to_sv(el->value()));
-    return map;
-}
-
 /**
  * Returns a hash buffer map from Flatbuffer proposal raw inputs.
  */
@@ -355,46 +315,6 @@ flatbuf_rawoutputs_to_hashbuffermap(const flatbuffers::Vector<flatbuffers::Offse
 //---Conversion helpers from std data types to flatbuffers data types---//
 //---These are used in constructing Flatbuffer messages using builders---//
 
-/**
- * Returns Flatbuffer bytes vector from string_view.
- */
-const flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
-sv_to_flatbuff_bytes(flatbuffers::FlatBufferBuilder &builder, std::string_view sv)
-{
-    return builder.CreateVector(reinterpret_cast<const uint8_t *>(sv.data()), sv.size());
-}
-
-/**
- * Returns Flatbuffer vector of ByteArrays from given set of strings.
- */
-const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ByteArray>>>
-stringlist_to_flatbuf_bytearrayvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_set<std::string> &set)
-{
-    std::vector<flatbuffers::Offset<ByteArray>> fbvec;
-    fbvec.reserve(set.size());
-    for (std::string_view str : set)
-        fbvec.push_back(CreateByteArray(builder, sv_to_flatbuff_bytes(builder, str)));
-    return builder.CreateVector(fbvec);
-}
-
-/**
- * Returns Flatbuffer vector of key value pairs from given map.
- */
-const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>>
-stringmap_to_flatbuf_bytepairvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map<std::string, const std::string> &map)
-{
-    std::vector<flatbuffers::Offset<BytesKeyValuePair>> fbvec;
-    fbvec.reserve(map.size());
-    for (auto const &[key, value] : map)
-    {
-        fbvec.push_back(CreateBytesKeyValuePair(
-            builder,
-            sv_to_flatbuff_bytes(builder, key),
-            sv_to_flatbuff_bytes(builder, value)));
-    }
-    return builder.CreateVector(fbvec);
-}
-
 /**
  * Returns Flatbuffer vector of RawInputs from a given map of hash buffer lists.
  */
diff --git a/src/p2p/peer_message_handler.hpp b/src/fbschema/p2pmsg_helpers.hpp
similarity index 52%
rename from src/p2p/peer_message_handler.hpp
rename to src/fbschema/p2pmsg_helpers.hpp
index e7f2fb41..7b6f9dab 100644
--- a/src/p2p/peer_message_handler.hpp
+++ b/src/fbschema/p2pmsg_helpers.hpp
@@ -1,16 +1,16 @@
-#ifndef _HP_PEER_MESSAGE_HANDLER_H_
-#define _HP_PEER_MESSAGE_HANDLER_H_
+#ifndef _HP_FBSCHEMA_P2PMSG_HELPERS_H_
+#define _HP_FBSCHEMA_P2PMSG_HELPERS_H_
 
 #include <string>
 #include <flatbuffers/flatbuffers.h>
-#include "message_content_generated.h"
-#include "message_container_generated.h"
-#include "p2p.hpp"
+#include "p2pmsg_container_generated.h"
+#include "p2pmsg_content_generated.h"
+#include "../p2p/p2p.hpp"
 
-namespace p2p
+namespace fbschema::p2pmsg
 {
 /**
- * This section contains Flatbuffer message reading/writing helpers.
+ * This section contains Flatbuffer p2p message reading/writing helpers.
  */
 
 //---Message validation and reading helpers---/
@@ -21,27 +21,17 @@ int validate_container_trust(const Container *container);
 
 int validate_and_extract_content(const Content **content_ref, const uint8_t *content_ptr, flatbuffers::uoffset_t content_size);
 
-const proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector<uint8_t> *pubkey);
+const p2p::proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector<uint8_t> *pubkey);
 
 //---Message creation helpers---//
 
-void create_msg_from_proposal(flatbuffers::FlatBufferBuilder &container_builder, const proposal &p);
+void create_msg_from_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::proposal &p);
 
 void create_containermsg_from_content(
     flatbuffers::FlatBufferBuilder &container_builder, const flatbuffers::FlatBufferBuilder &content_builder, bool sign);
 
 //---Conversion helpers from flatbuffers data types to std data types---//
 
-std::string_view flatbuff_bytes_to_sv(const uint8_t *data, flatbuffers::uoffset_t length);
-
-std::string_view flatbuff_bytes_to_sv(const flatbuffers::Vector<uint8_t> *buffer);
-
-const std::unordered_set<std::string>
-flatbuf_bytearrayvector_to_stringlist(const flatbuffers::Vector<flatbuffers::Offset<ByteArray>> *fbvec);
-
-const std::unordered_map<std::string, const std::string>
-flatbuf_pairvector_to_stringmap(const flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>> *fbvec);
-
 const std::unordered_map<std::string, const std::vector<util::hash_buffer>>
 flatbuf_rawinputs_to_hashbuffermap(const flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *fbvec);
 
@@ -50,15 +40,6 @@ flatbuf_rawoutputs_to_hashbuffermap(const flatbuffers::Vector<flatbuffers::Offse
 
 //---Conversion helpers from std data types to flatbuffers data types---//
 
-const flatbuffers::Offset<flatbuffers::Vector<uint8_t>>
-sv_to_flatbuff_bytes(flatbuffers::FlatBufferBuilder &builder, std::string_view sv);
-
-const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ByteArray>>>
-stringlist_to_flatbuf_bytearrayvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_set<std::string> &set);
-
-const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BytesKeyValuePair>>>
-stringmap_to_flatbuf_bytepairvector(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map<std::string, const std::string> &map);
-
 const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawInputList>>>
 hashbuffermap_to_flatbuf_rawinputs(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map<std::string, const std::vector<util::hash_buffer>> &map);
 
diff --git a/src/p2p/p2p.cpp b/src/p2p/p2p.cpp
index 9d766ec6..3b0a580a 100644
--- a/src/p2p/p2p.cpp
+++ b/src/p2p/p2p.cpp
@@ -6,6 +6,7 @@
 #include "../util.hpp"
 #include "../hplog.hpp"
 #include "p2p.hpp"
+#include "peer_session_handler.hpp"
 
 namespace ssl = boost::asio::ssl; // from <boost/asio/ssl.hpp>
 
diff --git a/src/p2p/peer_session_handler.cpp b/src/p2p/peer_session_handler.cpp
index 4efd81f5..8d5db921 100644
--- a/src/p2p/peer_session_handler.cpp
+++ b/src/p2p/peer_session_handler.cpp
@@ -4,11 +4,13 @@
 #include "../crypto.hpp"
 #include "../util.hpp"
 #include "../hplog.hpp"
+#include "../fbschema/p2pmsg_container_generated.h"
+#include "../fbschema/p2pmsg_content_generated.h"
+#include "../fbschema/p2pmsg_helpers.hpp"
 #include "p2p.hpp"
 #include "peer_session_handler.hpp"
-#include "peer_message_handler.hpp"
-#include "message_content_generated.h"
-#include "message_container_generated.h"
+
+namespace p2pmsg = fbschema::p2pmsg;
 
 namespace p2p
 {
@@ -40,7 +42,7 @@ void peer_session_handler::on_connect(sock::socket_session<peer_outbound_message
 {
     if (!session->flags[util::SESSION_FLAG::INBOUND])
     {
-        // We init the session unique id to associate with the challenge.
+        // We init the session unique id to associate with the peer.
         session->init_uniqueid();
         {
             std::lock_guard<std::mutex> lock(p2p::peer_connections_mutex);
@@ -48,23 +50,14 @@ void peer_session_handler::on_connect(sock::socket_session<peer_outbound_message
         }
         LOG_DBG << "Adding peer to list: " << session->uniqueid;
     }
-    else
-    {
-        // todo: set container builder defualt builder size to combination of serialized content length + signature length(which is fixed)
-        // peer_outbound_message msg(std::make_shared<flatbuffers::FlatBufferBuilder>(1024));
-
-        // proposal p;
-        // create_msg_from_proposal(msg.builder(), p);
-        // session->send(msg);
-    }
 }
 
 //peer session on message callback method
 //validate and handle each type of peer messages.
 void peer_session_handler::on_message(sock::socket_session<peer_outbound_message> *session, std::string_view message)
 {
-    const Container *container;
-    if (validate_and_extract_container(&container, message) != 0)
+    const p2pmsg::Container *container;
+    if (p2pmsg::validate_and_extract_container(&container, message) != 0)
         return;
 
     //Get serialised message content.
@@ -74,16 +67,16 @@ void peer_session_handler::on_message(sock::socket_session<peer_outbound_message
     const uint8_t *content_ptr = container_content->Data();
     flatbuffers::uoffset_t content_size = container_content->size();
 
-    const Content *content;
-    if (validate_and_extract_content(&content, content_ptr, content_size) != 0)
+    const p2pmsg::Content *content;
+    if (p2pmsg::validate_and_extract_content(&content, content_ptr, content_size) != 0)
         return;
 
-    p2p::Message content_message_type = content->message_type(); //i.e - proposal, npl, state request, state response, etc
+    p2pmsg::Message content_message_type = content->message_type(); //i.e - proposal, npl, state request, state response, etc
 
-    if (content_message_type == Message_Proposal_Message) //message is a proposal message
+    if (content_message_type == p2pmsg::Message_Proposal_Message) //message is a proposal message
     {
         // We only trust proposals coming from trusted peers.
-        if (validate_container_trust(container) != 0)
+        if (p2pmsg::validate_container_trust(container) != 0)
         {
             LOG_DBG << "Proposal rejected due to trust failure.";
             return;
@@ -92,11 +85,11 @@ void peer_session_handler::on_message(sock::socket_session<peer_outbound_message
         std::lock_guard<std::mutex> lock(collected_msgs.proposals_mutex); // Insert proposal with lock.
 
         collected_msgs.proposals.push_back(
-            create_proposal_from_msg(*content->message_as_Proposal_Message(), container->pubkey()));
+            p2pmsg::create_proposal_from_msg(*content->message_as_Proposal_Message(), container->pubkey()));
     }
-    else if (content_message_type == Message_Npl_Message) //message is a NPL message
+    else if (content_message_type == p2pmsg::Message_Npl_Message) //message is a NPL message
     {
-        const Npl_Message *npl = content->message_as_Npl_Message();
+        const p2pmsg::Npl_Message *npl = content->message_as_Npl_Message();
         // execute npl logic here.
         //broadcast message.
     }