serde.hpp

// Copyright (c) 2019-2022 Xenios SEZC
// https://www.veriblock.org
// Distributed under the MIT software license, see the accompanying
// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef ALT_INTEGRATION_VERIBLOCK_SERDE_HPP
#define ALT_INTEGRATION_VERIBLOCK_SERDE_HPP
 
#include <functional>
#include <iterator>
#include <stdexcept>
#include <vector>
 
#include "consts.hpp"
#include "entities/network_byte_pair.hpp"
#include "read_stream.hpp"
#include "slice.hpp"
#include "strutil.hpp"
#include "write_stream.hpp"
 
namespace altintegration {
 
struct AltChainParams;
 
bool checkRange(uint64_t num,
                uint64_t min,
                uint64_t max,
                ValidationState& state);
 
std::vector<uint8_t> trimmedArray(int64_t input);
 
template <typename T,
          typename = typename std::enable_if<std::is_integral<T>::value>::type>
std::vector<uint8_t> fixedArray(T input) {
  WriteStream inputStream;
  inputStream.writeBE(input);
  return inputStream.data();
}
 
bool readVarLenValue(ReadStream& stream,
                     Slice<const uint8_t>& out,
                     ValidationState& state,
                     uint64_t minLen,
                     uint64_t maxLen);
 
bool readSingleByteLenValue(ReadStream& stream,
                            Slice<const uint8_t>& out,
                            ValidationState& state,
                            uint64_t minLen,
                            uint64_t maxLen);
 
template <typename Container,
          typename = typename std::enable_if<
              sizeof(typename Container::value_type) == 1>::type>
bool readSingleByteLenValue(ReadStream& stream,
                            Container& out,
                            ValidationState& state,
                            uint64_t minLen,
                            uint64_t maxLen) {
  uint8_t length = 0;
  if (!stream.readBE<uint8_t>(length, state)) {
    return state.Invalid("readsingle-bad-length");
  }
  if (!checkRange(length, minLen, maxLen, state)) {
    return state.Invalid("readsingle-bad-range");
  }
  out.resize(length);
  return stream.read(length, out.data(), state);
}
 
template <typename T,
          typename = typename std::enable_if<std::is_integral<T>::value>::type>
bool readSingleBEValue(ReadStream& stream, T& out, ValidationState& state) {
  Slice<const uint8_t> data;
  if (!readSingleByteLenValue(stream, data, state, 0, sizeof(T))) {
    return state.Invalid("readsinglebe-bad-data");
  }
  ReadStream dataStream(data);
  return dataStream.readBE<T>(out, state, data.size());
}
 
void writeSingleByteLenValue(WriteStream& stream, Slice<const uint8_t> value);
 
void writeSingleBEValue(WriteStream& stream, int64_t value);
 
template <typename T,
          typename = typename std::enable_if<std::is_integral<T>::value>::type>
void writeSingleFixedBEValue(WriteStream& stream, T value) {
  WriteStream dataStream;
  dataStream.writeBE<T>(value);
  writeSingleByteLenValue(stream, dataStream.data());
}
 
void writeVarLenValue(WriteStream& stream, Slice<const uint8_t> value);
 
size_t singleByteLenValueSize(Slice<const uint8_t> value);
 
size_t singleByteLenValueSize(size_t valueSize);
 
size_t singleBEValueSize(int64_t value);
 
template <typename T,
          typename = typename std::enable_if<std::is_integral<T>::value>::type>
size_t singleFixedBEValueSize(T value) {
  WriteStream dataStream;
  dataStream.writeBE<T>(value);
  return singleByteLenValueSize(dataStream.data());
}
 
size_t varLenValueSize(Slice<const uint8_t> value);
 
size_t varLenValueSize(size_t valueSize);
 
NetworkBytePair readNetworkByte(ReadStream& stream, TxType type);
 
bool readNetworkByte(ReadStream& stream,
                     TxType type,
                     NetworkBytePair& out,
                     ValidationState& state);
 
void writeNetworkByte(WriteStream& stream, NetworkBytePair networkOrType);
 
size_t networkByteSize(NetworkBytePair networkOrType);
 
template <typename Container>
bool readSetOf(ReadStream& stream,
               Container& out,
               ValidationState& state,
               size_t min,
               size_t max,
               std::function<bool(ReadStream&,
                                  typename Container::value_type&,
                                  ValidationState&)> readFunc) {
  int32_t count = 0;
  if (!readSingleBEValue<int32_t>(stream, count, state)) {
    return state.Invalid("readarray-bad-count");
  }
  if (!checkRange(count, min, max, state)) {
    return state.Invalid("readarray-bad-range");
  }
 
  for (size_t i = 0; i < (size_t)count; i++) {
    typename Container::value_type item;
    if (!readFunc(stream, item, state)) {
      return state.Invalid("readarray-bad-item", i);
    }
    if (out.insert(item).second == false) {
      return state.Invalid("readarray-duplicate-item", i);
    }
  }
 
  return true;
}
 
template <typename Container>
bool readSetOf(ReadStream& stream,
               Container& out,
               ValidationState& state,
               std::function<bool(Container&,
                                  ReadStream&,
                                  typename Container::value_type&,
                                  ValidationState&)> readFunc) {
  int32_t max = std::numeric_limits<int32_t>::max();
  return readContainer(stream, out, state, 0, max, readFunc);
}
 
template <typename T>
bool readArrayOf(
    ReadStream& stream,
    std::vector<T>& out,
    ValidationState& state,
    size_t min,
    size_t max,
    std::function<bool(ReadStream&, T&, ValidationState&)> readFunc) {
  int32_t count = 0;
  if (!readSingleBEValue<int32_t>(stream, count, state)) {
    return state.Invalid("readarray-bad-count");
  }
  if (!checkRange(count, min, max, state)) {
    return state.Invalid("readarray-bad-range");
  }
 
  out.reserve(count);
 
  for (size_t i = 0; i < (size_t)count; i++) {
    T item;
    if (!readFunc(stream, item, state)) {
      return state.Invalid("readarray-bad-item", i);
    }
    out.push_back(item);
  }
 
  return true;
}
 
template <typename T>
bool readArrayOf(
    ReadStream& stream,
    std::vector<T>& out,
    ValidationState& state,
    std::function<bool(ReadStream&, T&, ValidationState&)> readFunc) {
  int32_t max = std::numeric_limits<int32_t>::max();
  return readArrayOf<T>(stream, out, state, 0, max, readFunc);
}
 
template <typename Container>
void writeContainer(
    WriteStream& w,
    const Container& t,
    std::function<void(WriteStream&, const typename Container::value_type& t)>
        f) {
  writeSingleBEValue(w, (int64_t)t.size());
  for (auto& v : t) {
    f(w, v);
  }
}
 
template <typename Container>
size_t estimateContainerSize(
    const Container& t,
    std::function<size_t(const typename Container::value_type& t)> f) {
  size_t size = 0;
  size += singleBEValueSize((int64_t)t.size());
  for (auto& v : t) {
    size += f(v);
  }
  return size;
}
 
template <typename T>
size_t estimateArraySizeOf(const std::vector<T>& t,
                           std::function<size_t(const T& t)> f) {
  return estimateContainerSize<std::vector<T>>(t, f);
}
 
template <typename T>
bool DeserializeFromVbkEncoding(Slice<const uint8_t> data,
                                T& out,
                                ValidationState& state) {
  ReadStream stream(data);
  return DeserializeFromVbkEncoding(stream, out, state);
}
 
template <typename T>
bool DeserializeFromRaw(Slice<const uint8_t> data,
                        T& out,
                        ValidationState& state) {
  ReadStream stream(data);
  return DeserializeFromRaw(stream, out, state);
}
 
template <typename T>
bool DeserializeFromHex(const std::string& hex,
                        T& out,
                        ValidationState& state) {
  auto data = ParseHex(hex);
  ReadStream stream(data);
  return DeserializeFromVbkEncoding(stream, out, state);
}
 
template <typename T>
bool DeserializeFromRawHex(const std::string& hex,
                           T& out,
                           ValidationState& state) {
  auto data = ParseHex(hex);
  ReadStream stream(data);
  return DeserializeFromRaw(stream, out, state);
}
 
template <typename T>
std::vector<uint8_t> SerializeToVbkEncoding(const T& obj) {
  WriteStream w;
  obj.toVbkEncoding(w);
  return w.data();
}
 
template <typename T>
std::vector<uint8_t> SerializeToRaw(const T& obj) {
  WriteStream w;
  obj.toRaw(w);
  return w.data();
}
 
template <typename T>
std::string SerializeToHex(const T& obj) {
  return HexStr(SerializeToVbkEncoding<T>(obj));
}
 
template <typename T>
std::string SerializeToRawHex(const T& obj) {
  return HexStr(SerializeToRaw<T>(obj));
}
 
template <typename T>
T AssertDeserializeFromRaw(std::vector<uint8_t> raw) {
  T t;
  ValidationState state;
  bool result = DeserializeFromRaw(raw, t, state);
  VBK_ASSERT_MSG(result, "Can't deserialize: %s", state.toString());
  return t;
}
 
template <typename T>
T AssertDeserializeFromVbkEncoding(Slice<const uint8_t> raw) {
  T t;
  ValidationState state;
  bool result = DeserializeFromVbkEncoding(raw, t, state);
  VBK_ASSERT_MSG(result, "Can't deserialize: %s", state.toString());
  return t;
}
 
template <typename T>
T AssertDeserializeFromHex(std::string hex) {
  T t;
  ValidationState state;
  bool result = DeserializeFromHex(hex, t, state);
  VBK_ASSERT_MSG(result, "Can't deserialize: %s", state.toString());
  return t;
}
 
template <typename T>
T AssertDeserializeFromRawHex(std::string hex) {
  T t;
  ValidationState state;
  bool result = DeserializeFromRawHex(hex, t, state);
  VBK_ASSERT_MSG(result, "Can`t deserialize: %s", state.toString());
  return t;
}
 
}  // namespace altintegration
 
#endif  // ALT_INTEGRATION_SERDE_HPP