ARCHIVE/hpcore
1
0
Fork 0
mirror of https://github.com/EvernodeXRPL/hpcore.git synced 2026-04-29 15:37:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reorganised flatbuf schema files and helper funcs.

Browse Source
This commit is contained in:
Ravin Perera
2019-10-28 20:11:28 +05:30
parent 2715ff7242
commit 1fa19c381f
14 changed files with 441 additions and 387 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@@ -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

8
src/cons/cons.cpp
View File

@@ -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.

93
src/fbschema/common_helpers.cpp Normal file
View File

@@ -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

40
src/fbschema/common_helpers.hpp Normal file
View File

@@ -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

11
src/fbschema/common_schema.fbs Normal file
View File

@@ -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];
}

140
src/fbschema/common_schema_generated.h Normal file
View File

@@ -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_

4
src/p2p/message_container.fbs → src/fbschema/p2pmsg_container.fbs
View File

@@ -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;

33
src/p2p/message_container_generated.h → src/fbschema/p2pmsg_container_generated.h
View File

@@ -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_

12
src/p2p/message_content.fbs → src/fbschema/p2pmsg_content.fbs
View File

@@ -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 {

309
src/p2p/message_content_generated.h → src/fbschema/p2pmsg_content_generated.h
View File

@@ -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_

98
src/p2p/peer_message_handler.cpp → src/fbschema/p2pmsg_helpers.cpp
View File

@@ -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.
*/

37
src/p2p/peer_message_handler.hpp → src/fbschema/p2pmsg_helpers.hpp
View File

@@ -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);

1
src/p2p/p2p.cpp
View File

@@ -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>

39
src/p2p/peer_session_handler.cpp
View File

@@ -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.
}